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

// Import
var changestype_Drawing_Props = AscCommon.changestype_Drawing_Props;
var changestype_2_ElementsArray_and_Type = AscCommon.changestype_2_ElementsArray_and_Type;
var isRealObject = AscCommon.isRealObject;
var global_mouseEvent = AscCommon.global_mouseEvent;
var History = AscCommon.History;

var DrawingObjectsController = AscFormat.DrawingObjectsController;
var HANDLE_EVENT_MODE_HANDLE = AscFormat.HANDLE_EVENT_MODE_HANDLE;
var HANDLE_EVENT_MODE_CURSOR = AscFormat.HANDLE_EVENT_MODE_CURSOR;

var asc_CImgProperty = Asc.asc_CImgProperty;

var c_oAscAlignH         = Asc.c_oAscAlignH;
var c_oAscAlignV         = Asc.c_oAscAlignV;

function CGraphicObjects(document, drawingDocument, api)
{
    this.api = api;
    this.document = document;
    this.drawingDocument = drawingDocument;

    this.graphicPages = [];

    this.startTrackPos =
    {
        x: null,
        y: null,
        pageIndex: null
    };

    this.arrPreTrackObjects = [];
    this.arrTrackObjects = [];


    this.curState = new AscFormat.NullState(this);

    this.selectionInfo =
    {
        selectionArray: []
    };

    this.maximalGraphicObjectZIndex = 1024;

    this.spline = null;
    this.polyline = null;

    this.drawingObjects = [];


    this.urlMap = [];
    this.recalcMap = {};

    this.selectedObjects = [];
    this.selection =
    {
        groupSelection:       null,
        chartSelection:       null,
        textSelection:        null,
        wrapPolygonSelection: null
    };

    this.selectedObjects = [];

    this.handleEventMode = HANDLE_EVENT_MODE_HANDLE;

    this.nullState = new AscFormat.NullState(this);
    this.bNoCheckChartTextSelection = false;

    this.Id = AscCommon.g_oIdCounter.Get_NewId();
    this.Lock = new AscCommon.CLock();
    AscCommon.g_oTableId.Add( this, this.Id );
}

CGraphicObjects.prototype =
{
    createShape: DrawingObjectsController.prototype.createShape,

    handleAdjustmentHit: DrawingObjectsController.prototype.handleAdjustmentHit,
    handleHandleHit: DrawingObjectsController.prototype.handleHandleHit,
    handleMoveHit: DrawingObjectsController.prototype.handleMoveHit,
    handleEnter: DrawingObjectsController.prototype.handleEnter,

    rotateTrackObjects: DrawingObjectsController.prototype.rotateTrackObjects,
    handleRotateTrack: DrawingObjectsController.prototype.handleRotateTrack,
    trackResizeObjects: DrawingObjectsController.prototype.trackResizeObjects,
    trackGeometryObjects: DrawingObjectsController.prototype.trackGeometryObjects,
    resetInternalSelection: DrawingObjectsController.prototype.resetInternalSelection,
    handleTextHit: DrawingObjectsController.prototype.handleTextHit,
    getConnectorsForCheck: DrawingObjectsController.prototype.getConnectorsForCheck,
    getConnectorsForCheck2: DrawingObjectsController.prototype.getConnectorsForCheck2,
    checkDrawingHyperlinkAndMacro: DrawingObjectsController.prototype.checkDrawingHyperlinkAndMacro,
    canEditTableOleObject: DrawingObjectsController.prototype.canEditTableOleObject,
    canEditGeometry: DrawingObjectsController.prototype.canEditGeometry,
    startEditGeometry: DrawingObjectsController.prototype.startEditGeometry,
    haveTrackedObjects: DrawingObjectsController.prototype.haveTrackedObjects,
    checkShowMediaControlOnSelect: function () {
    },
    checkShowMediaControlOnHover: function (oDrawing) {
    },

    checkSelectedObjectsAndCallback: function(callback, args, bNoSendProps, nHistoryPointType, aAdditionaObjects, bNoCheckLock)
    {
    	var oLogicDocument = editor.WordControl.m_oLogicDocument;

        var check_type = AscCommon.changestype_Drawing_Props;
        if(bNoCheckLock || oLogicDocument.Document_Is_SelectionLocked(check_type, null, false, false) === false)
        {
            var nPointType = AscFormat.isRealNumber(nHistoryPointType) ? nHistoryPointType : AscDFH.historydescription_CommonControllerCheckSelected;
			oLogicDocument.StartAction(nPointType);
            callback.apply(this, args);
			oLogicDocument.Recalculate();
			oLogicDocument.FinalizeAction();
        }
    },

    AddContentControl: function(nContentControlType)
    {
        var oTargetDocContent = this.getTargetDocContent();
        if(oTargetDocContent && (!oTargetDocContent.bPresentation || nContentControlType === Asc.c_oAscSdtLevelType.Inline && !oTargetDocContent.Is_ChartTitleContent())){
            return oTargetDocContent.AddContentControl(nContentControlType);
        }

        return null;
    },

    Get_Id: function()
    {
        return this.Id;
    },

    GetAllFields: function(isUseSelection, arrFields){
        var _arrFields = arrFields ? arrFields : [];
        for(var i = 0; i < this.selectedObjects.length; ++i){
            this.selectedObjects[i].GetAllFields(isUseSelection, arrFields);
        }
        return _arrFields;
    },

    TurnOffCheckChartSelection: function()
    {
        this.bNoCheckChartTextSelection = true;
    },

    TurnOnCheckChartSelection: function()
    {
        this.bNoCheckChartTextSelection = false;
    },


    getDrawingDocument: function()
    {
        return editor.WordControl.m_oDrawingDocument;
    },
    sortDrawingArrays: function()
    {
        for(var i = 0; i < this.graphicPages.length; ++i)
        {
            if(this.graphicPages[i])
                this.graphicPages[i].sortDrawingArrays();
        }
    },

    getSelectedObjects: function()
    {
        return this.selectedObjects;
    },

    getSelectedArray: DrawingObjectsController.prototype.getSelectedArray,

    getSelectedOleObjects: DrawingObjectsController.prototype.getSelectedOleObjects,

    getTheme: function()
    {
        return this.document.theme;
    },

    getColorMapOverride: function()
    {
        return null;
    },

    isViewMode: function()
    {
        return this.document.IsViewMode();
    },

    convertPixToMM: function(v)
    {
        return this.document.DrawingDocument.GetMMPerDot(v);
    },

    getGraphicInfoUnderCursor: function(pageIndex, x, y)
    {
        this.handleEventMode = HANDLE_EVENT_MODE_CURSOR;
        var ret = this.curState.onMouseDown(global_mouseEvent, x, y, pageIndex, false);
        this.handleEventMode = HANDLE_EVENT_MODE_HANDLE;
        if(ret && ret.cursorType === "text")
        {
            if((this.selection.chartSelection && this.selection.chartSelection.selection.textSelection) ||
                (this.selection.groupSelection && this.selection.groupSelection.selection.chartSelection && this.selection.groupSelection.selection.chartSelection.selection.textSelection))
            {
                ret = {};
            }
        }
        return ret || {};
    },

    updateCursorType: function(pageIndex, x, y, e, bTextFlag)
    {
        var ret;
        this.handleEventMode = HANDLE_EVENT_MODE_CURSOR;
        ret = this.curState.onMouseDown(global_mouseEvent, x, y, pageIndex, bTextFlag);
        this.handleEventMode = HANDLE_EVENT_MODE_HANDLE;
        if(ret)
        {
            if(ret.cursorType !== "text")
            {
                var oApi = Asc.editor || editor;
                var isDrawHandles = oApi ? oApi.isShowShapeAdjustments() : true;

                var oShape     = AscCommon.g_oTableId.Get_ById(ret.objectId);
                var oInnerForm = null;
                if (oShape && oShape.isForm() && (oInnerForm = oShape.getInnerForm()))
				{
					if (isDrawHandles && oInnerForm.IsFormLocked())
						isDrawHandles = false;

					// Данная ситуация обрабатывается отдельно, т.к. картиночная форма находится внутри другой
					// автофигуры и мы специально не даем заходить во внутреннюю, поэтому дополнительно здесь
					// обрабатываем попадание в ContentControl
					var oPara;
					if (oInnerForm.IsPictureForm() && oInnerForm.IsFixedForm() && (oPara = oInnerForm.GetParagraph()))
					{
						var X = x, Y = y;
						var oTransform = oPara.Get_ParentTextInvertTransform();
						if (oTransform)
						{
							X = oTransform.TransformPointX(x, y);
							Y = oTransform.TransformPointY(x, y);
						}

						oInnerForm.DrawContentControlsTrack(AscCommon.ContentControlTrack.Hover, X, Y, 0);
					}
				}

                if(isDrawHandles === false)
                {
                    this.drawingDocument.SetCursorType("default");
                    return true;
                }
				let sCursorType = ret.cursorType;
				let oAPI = this.getEditorApi();
				if(oAPI.isFormatPainterOn())
				{
					if(sCursorType !== "text")
					{
						let oData = oAPI.getFormatPainterData();
						if(oData.isDrawingData())
						{
							sCursorType = AscCommon.Cursors.ShapeCopy;
						}
					}
				}
                this.drawingDocument.SetCursorType(sCursorType);
            }
            return true;
        }
        return false;
    },

    removeTextSelection: function(){
        var oTargetDocContent = this.getTargetDocContent();
        if(oTargetDocContent && oTargetDocContent.IsSelectionUse()){
            oTargetDocContent.RemoveSelection();
        }
    },

	getDefaultText: DrawingObjectsController.prototype.getDefaultText,
    canEdit: DrawingObjectsController.prototype.canEdit,
    createImage: DrawingObjectsController.prototype.createImage,
    createOleObject: DrawingObjectsController.prototype.createOleObject,
    createTextArt: DrawingObjectsController.prototype.createTextArt,
    getOleObject: DrawingObjectsController.prototype.getOleObject,
    getChartObject: DrawingObjectsController.prototype.getChartObject,
    getChartSpace2: DrawingObjectsController.prototype.getChartSpace2,
    getChartInfo: DrawingObjectsController.prototype.getChartInfo,
    CreateDocContent: DrawingObjectsController.prototype.CreateDocContent,
    isSlideShow: function()
    {
        return false;
    },

    isObjectsProtected: function()
    {
        return false;
    },

    checkSelectedObjectsProtection: function()
    {
        return false;
    },
    checkSelectedObjectsProtectionText: function()
    {
        return false;
    },

    clearPreTrackObjects: function()
    {
        this.arrPreTrackObjects.length = 0;
    },

    addPreTrackObject: function(preTrackObject)
    {
        this.arrPreTrackObjects.push(preTrackObject);
    },

    clearTrackObjects: function()
    {
        this.arrTrackObjects.length = 0;
    },

    addTrackObject: function(trackObject)
    {
        this.arrTrackObjects.push(trackObject);
    },

    swapTrackObjects: function()
    {
        this.clearTrackObjects();
        for(var i = 0; i < this.arrPreTrackObjects.length; ++i)
        {
            this.addTrackObject(this.arrPreTrackObjects[i]);
        }
        if(this.arrPreTrackObjects.length > 1)
        {
            var aAllDrawings;
            var oFirstTrack = this.arrPreTrackObjects[0];
            if(oFirstTrack)
            {
                var oOrigObj = oFirstTrack.originalObject;
                if(oOrigObj)
                {
                    if(oOrigObj.group)
                    {
                        aAllDrawings = [];
                    }
                    else
                    {
                        var oGrPage = this.getGraphicPage(oOrigObj.selectStartPage);
                        if(oGrPage && oGrPage.getAllDrawings)
                        {
                            var aParaDrawings = oGrPage.getAllDrawings();
                            if(Array.isArray(aParaDrawings))
                            {
                                aAllDrawings = [];
                                for(var nDrawing = 0; nDrawing < aParaDrawings.length; ++nDrawing)
                                {
                                    if(aParaDrawings[nDrawing].GraphicObj)
                                    {
                                        aAllDrawings.push(aParaDrawings[nDrawing].GraphicObj);
                                    }
                                }
                            }
                            aAllDrawings = oGrPage.getAllDrawings();
                        }
                    }
                    AscFormat.fSortTrackObjects(this, aAllDrawings);
                }
            }
        }
        this.clearPreTrackObjects();
    },

    getGraphicPage: function(pageIndex)
    {
        var drawing_page;
        if(this.document.GetDocPosType() !== docpostype_HdrFtr)
        {
            drawing_page = this.graphicPages[pageIndex];
        }
        else
        {
            drawing_page = this.getHdrFtrObjectsByPageIndex(pageIndex);
        }
        return drawing_page;
    },

    addToRecalculate: function(object)
    {
		if (object && object.Get_Id && object.recalculate) {
			History.RecalcData_Add({Type : AscDFH.historyitem_recalctype_Drawing, Object : object});
			if (object.checkAutofit && object.checkAutofit()) {
				let mainObject = object.group && object.getMainGroup ? object.getMainGroup() : object;
				if (mainObject && mainObject.parent) {
					mainObject.parent.Refresh_RecalcData({Type : AscDFH.historyitem_Drawing_SetExtent});
				}
			}
		}
    },

    createWatermarkImage: DrawingObjectsController.prototype.createWatermarkImage,


    getAllInksShapes: function ()
    {
        let aDrawings = this.document.GetAllDrawingObjects();
        let aInksDrawings = [];
        for(let nIdx = 0; nIdx < aDrawings.length; ++nIdx)
        {
            let oDrawing = aDrawings[nIdx];
            if(oDrawing.GraphicObj.isInk() || oDrawing.GraphicObj.isHaveOnlyInks())
            {
                aInksDrawings.push(oDrawing.GraphicObj);
            } else {
							oDrawing.GraphicObj.getAllInks(aInksDrawings);
						}
        }
        return aInksDrawings;
    },
    haveInks: function ()
    {
        return this.getAllInksShapes().length > 0;
    },
	removeAllInks: function() {
		let aInkShapes = this.getAllInksShapes();
		if (aInkShapes.length > 0) {
			const arrDrawings = [];
			for (let nIdx = 0; nIdx < aInkShapes.length; ++nIdx) {
				let oShape = aInkShapes[nIdx];
				const oDrawing = oShape.GetParaDrawing();
				if (oDrawing) {
					arrDrawings.push(oDrawing);
				}
			}
			if (this.document.Document_Is_SelectionLocked(changestype_None, {
				Type:      changestype_2_ElementsArray_and_Type,
				Elements:  arrDrawings,
				CheckType: AscCommon.changestype_Drawing_Props
			})) {
				return;
			}
			this.document.StartAction(AscDFH.historydescription_RemoveAllInks);
			const oGroups = {};
			for (let i = 0; i < aInkShapes.length; i++) {
				const oShape = aInkShapes[i];
				if (oShape.parent instanceof AscCommonWord.ParaDrawing) {
					oShape.parent.Remove_FromDocument(false);
					if (oShape.isGroup()) {
						oShape.deselectInternal(this);
					}
					this.deselectObject(oShape);
				} else if (oShape.group) {
					const oMainGroup = oShape.getMainGroup();
					const sGroupId = oMainGroup.Get_Id();
					if (!oGroups[sGroupId]) {
						oGroups[sGroupId] = {group: oMainGroup, shapes: []};
					}
					oGroups[sGroupId].shapes.push(oShape);
					if (oShape.isGroup()) {
						oShape.deselectInternal(this);
					}
				}
			}
			for (let sId in oGroups) {
				const oGroupInfo = oGroups[sId];
				this.removeFromGroup(oGroupInfo.group, oGroupInfo.shapes);
			}
			this.document.UpdateSelection();
			this.document.Recalculate();
			this.document.FinalizeAction();
		}
	},


    createWatermark: function(oProps)
    {
        if(oProps.get_Type() === Asc.c_oAscWatermarkType.None)
        {
            return null;
        }

		let bTrackRevisions = false;
		if (this.document.IsTrackRevisions())
		{
			bTrackRevisions = this.document.GetLocalTrackRevisions();
			this.document.SetLocalTrackRevisions(false);
		}

        let oDrawing, extX, extY;
        let oSectPr = this.document.Get_SectionProps();
        let dMaxWidth = oSectPr.get_W() - oSectPr.get_LeftMargin() - oSectPr.get_RightMargin();
        let dMaxHeight = oSectPr.get_H() - oSectPr.get_TopMargin() - oSectPr.get_BottomMargin();
        let nOpacity = oProps.get_Opacity();
        if(oProps.get_Type() === Asc.c_oAscWatermarkType.Image)
        {
            var oImgP = new Asc.asc_CImgProperty();
            oImgP.ImageUrl = oProps.get_ImageUrl();
            var oSize = oImgP.asc_getOriginSize(this.getEditorApi());
            var dScale = oProps.get_Scale();
            let nImageW = oProps.get_ImageWidth();
            let nImageH = oProps.get_ImageHeight();
            if(AscFormat.isRealNumber(nImageW) && AscFormat.isRealNumber(nImageH) &&
                nImageW > 0 && nImageH > 0) {
                extX = nImageW / 36000;
                extY = nImageH / 36000;
            }
            else if(dScale < 0)
            {
                let nImageW = oProps.get_ImageWidth();
                let nImageH = oProps.get_ImageWidth();
                if(AscFormat.isRealNumber(nImageW) && AscFormat.isRealNumber(nImageH) &&
                    nImageW > 0 && nImageH > 0) {
                    extX = nImageW / 36000;
                    extY = nImageH / 36000;
                }
                else {
                    extX = dMaxWidth;
                    extY = oSize.asc_getImageHeight() * (extX / oSize.asc_getImageWidth());
                    if(extY > dMaxHeight)
                    {
                        extY = dMaxHeight;
                        extX = oSize.asc_getImageWidth() * (extY / oSize.asc_getImageHeight());
                    }
                }
            }
            else
            {
                extX = oSize.asc_getImageWidth() * dScale;
                extY = oSize.asc_getImageHeight() * dScale;
            }
            oDrawing = this.createImage(oProps.get_ImageUrl(), 0, 0, extX, extY, null, null);
            let dRot = oProps.getXfrmRot();
            let bZeroAngle = AscFormat.fApproxEqual(0.0, dRot);
            if(!bZeroAngle)
            {
                oDrawing.spPr.xfrm.setRot(dRot);
            }
            if(AscFormat.isRealNumber(nOpacity) && nOpacity < 255)
            {
                if(oDrawing.blipFill)
                {
                    let oBlipFill = oDrawing.blipFill.createDuplicate();
                    let oEffect = new AscFormat.CAlphaModFix();
                    let nAmt = ((255 - nOpacity) / 255) * 100000 + 0.5 >> 0;
                    oEffect.amt = Math.max(0, Math.min(100000, nAmt));
                    oBlipFill.Effects.push(oEffect);
                    oDrawing.setBlipFill(oBlipFill);
                }
            }
        }
        else
        {
            var oTextPropMenu = oProps.get_TextPr();
            oDrawing = new AscFormat.CShape();
            oDrawing.setWordShape(true);
            oDrawing.setBDeleted(false);
            oDrawing.createTextBoxContent();
            var oSpPr = new AscFormat.CSpPr();
            var oXfrm = new AscFormat.CXfrm();
            oXfrm.setOffX(0);
            oXfrm.setOffY(0);
            oXfrm.setExtX(5);
            oXfrm.setExtY(5);
            let dRot = oProps.getXfrmRot();
            let bZeroAngle = AscFormat.fApproxEqual(0.0, dRot);
            if(!bZeroAngle)
            {
                oXfrm.setRot(dRot);
            }
            oSpPr.setXfrm(oXfrm);
            oXfrm.setParent(oSpPr);
            oSpPr.setFill(AscFormat.CreateNoFillUniFill());
            oSpPr.setLn(AscFormat.CreateNoFillLine());
            oSpPr.setGeometry(AscFormat.CreateGeometry("rect"));
            oDrawing.setSpPr(oSpPr);
            oSpPr.setParent(oDrawing);
            var oContent = oDrawing.getDocContent();
            AscFormat.AddToContentFromString(oContent, oProps.get_Text());
            var oTextPr = new CTextPr();
            oTextPr.FontSize = (oTextPropMenu.get_FontSize() > 0 ? oTextPropMenu.get_FontSize() : 20);
            oTextPr.RFonts.SetAll(oTextPropMenu.get_FontFamily().get_Name(), -1);
            oTextPr.Bold = oTextPropMenu.get_Bold();
            oTextPr.HighLight = oTextPropMenu.get_HighLight();
            oTextPr.Italic = oTextPropMenu.get_Italic();
            oTextPr.Underline = oTextPropMenu.get_Underline();
            oTextPr.Strikeout = oTextPropMenu.get_Strikeout();
            oTextPr.TextFill = AscFormat.CreateUnifillFromAscColor(oTextPropMenu.get_Color(), 1);
            let nOpacity = oProps.get_Opacity();
            if(AscFormat.isRealNumber(nOpacity) && nOpacity < 255)
            {
                oTextPr.TextFill.transparent = (nOpacity >> 0);
            }
            if(null !== oTextPropMenu.get_Lang())
            {
                oTextPr.SetLang(oTextPropMenu.get_Lang());
            }
            oContent.SetApplyToAll(true);
            oContent.AddToParagraph(new ParaTextPr(oTextPr));
            oContent.SetParagraphAlign(AscCommon.align_Center);
            oContent.SetParagraphSpacing({Before : 0, After: 0,  LineRule : Asc.linerule_Auto, Line : 1.0});
            oContent.SetParagraphIndent({FirstLine:0, Left:0, Right:0});
            oContent.SetApplyToAll(false);
            var oBodyPr = oDrawing.getBodyPr().createDuplicate();
            oBodyPr.rot = 0;
            oBodyPr.spcFirstLastPara = false;
            oBodyPr.vertOverflow = AscFormat.nVOTOverflow;
            oBodyPr.horzOverflow = AscFormat.nHOTOverflow;
            oBodyPr.vert = AscFormat.nVertTThorz;
            oBodyPr.resetInsets();
            oBodyPr.numCol = 1;
            oBodyPr.spcCol = 0;
            oBodyPr.rtlCol = 0;
            oBodyPr.fromWordArt = false;
            oBodyPr.anchor = 1;
            oBodyPr.anchorCtr = false;
            oBodyPr.forceAA = false;
            oBodyPr.compatLnSpc = true;
            oBodyPr.prstTxWarp = null;
            oDrawing.setBodyPr(oBodyPr);

            var oContentSize = AscFormat.GetContentOneStringSizes(oContent);
            oXfrm.setExtX(oContentSize.w + 1);
            oXfrm.setExtY(oContentSize.h);
            if(oTextPropMenu.get_FontSize() < 0)
            {
                if(!bZeroAngle)
                {
                    extX = Math.SQRT2*Math.min(dMaxWidth, dMaxHeight) / (oContentSize.h / oContentSize.w + 1);
                }
                else
                {
                    extX = dMaxWidth;
                }
                oTextPr.FontSize *= (extX / oContentSize.w);
                oContent.SetApplyToAll(true);
                oContent.AddToParagraph(new ParaTextPr(oTextPr));
                oContent.SetApplyToAll(false);
                oContentSize = AscFormat.GetContentOneStringSizes(oContent);
                oXfrm.setExtX(extX + 1);
                oXfrm.setExtY(oContentSize.h);
            }
        }
        var oParaDrawing = null;
        if(oDrawing)
        {
            oParaDrawing   = new ParaDrawing(oDrawing.spPr.xfrm.extX, oDrawing.spPr.xfrm.extY, oDrawing, this.document.DrawingDocument, this.document, null);
            oDrawing.setParent(oParaDrawing);
            oParaDrawing.Set_GraphicObject(oDrawing);
            oParaDrawing.setExtent(oDrawing.spPr.xfrm.extX, oDrawing.spPr.xfrm.extY);
            oParaDrawing.Set_DrawingType(drawing_Anchor);
            oParaDrawing.Set_WrappingType(WRAPPING_TYPE_NONE);
            oParaDrawing.Set_BehindDoc(true);
            oParaDrawing.Set_Distance(3.2, 0, 3.2, 0);
            oParaDrawing.Set_PositionH(Asc.c_oAscRelativeFromH.Margin, true,  Asc.c_oAscAlignH.Center, false);
            oParaDrawing.Set_PositionV(Asc.c_oAscRelativeFromV.Margin, true,  Asc.c_oAscAlignV.Center, false);
	        ++AscFormat.Ax_Counter.GLOBAL_AX_ID_COUNTER;
			oParaDrawing.docPr.setName("PowerPlusWaterMarkObject" + AscFormat.Ax_Counter.GLOBAL_AX_ID_COUNTER)
        }

        if (false !== bTrackRevisions)
        {
            this.document.SetLocalTrackRevisions(bTrackRevisions);
        }

        return oParaDrawing;
    },

    getTrialImage: function(sImageUrl)
    {
        return AscFormat.ExecuteNoHistory(function(){
            var oParaDrawing = new ParaDrawing();
            oParaDrawing.Set_PositionH(Asc.c_oAscRelativeFromH.Page, true, c_oAscAlignH.Center, undefined);
            oParaDrawing.Set_PositionV(Asc.c_oAscRelativeFromV.Page, true, c_oAscAlignV.Center, undefined);
            oParaDrawing.Set_WrappingType(WRAPPING_TYPE_NONE);
            oParaDrawing.Set_BehindDoc( false );
            oParaDrawing.Set_Distance( 3.2, 0, 3.2, 0 );
            oParaDrawing.Set_DrawingType(drawing_Anchor);
            var oShape = this.createWatermarkImage(sImageUrl);
            oParaDrawing.Extent.W = oShape.spPr.xfrm.extX;
            oParaDrawing.Extent.H = oShape.spPr.xfrm.extY;
            oShape.setParent(oParaDrawing);
            oParaDrawing.Set_GraphicObject(oShape);
            return oParaDrawing;
        }, this, []);

    },
	
	recalculateAll : function()
	{
		for (let iDrawing = 0; iDrawing < this.drawingObjects.length; ++iDrawing)
		{
			let drawing = this.drawingObjects[iDrawing];
			let shape   = drawing ? drawing.GraphicObj : null;
			if (!shape)
				continue;
			if (shape.recalcText)
				shape.recalcText();
			if (shape.handleUpdateExtents)
				shape.handleUpdateExtents();
			shape.recalculate();
		}
		for (let iDrawing = 0; iDrawing < this.drawingObjects.length; ++iDrawing)
		{
			let drawing = this.drawingObjects[iDrawing];
			let shape   = drawing ? drawing.GraphicObj : null;
			if (!shape)
				continue;
            if (shape.recalculateText)
                shape.recalculateText();
		}
	},
	
	recalculate : function(data)
	{
		if (!data || data.All || !data.Map)
			return this.recalculateAll();
		
		let shapeMap = data.Map;
        //recalculate drawings and text in drawings separately
        //to be assured that all internal drawings have calculated sizes to be correctly measured
		for (let id in shapeMap)
		{
			if (!shapeMap.hasOwnProperty(id))
				continue;
			
			let shape = shapeMap[id];
			if (!shape.IsUseInDocument())
				continue;
			
			shape.recalculate();

		}
		for (let id in shapeMap)
		{
			if (!shapeMap.hasOwnProperty(id))
				continue;

			let shape = shapeMap[id];
			if (!shape.IsUseInDocument())
				continue;

			if (shape.recalculateText)
				shape.recalculateText();
		}
	},


    selectObject: DrawingObjectsController.prototype.selectObject,

    checkSelectedObjectsForMove: DrawingObjectsController.prototype.checkSelectedObjectsForMove,

    getDrawingProps: DrawingObjectsController.prototype.getDrawingProps,
    getDrawingPropsFromArray: DrawingObjectsController.prototype.getDrawingPropsFromArray,
    getSelectedObjectsByTypes: DrawingObjectsController.prototype.getSelectedObjectsByTypes,
		getChartSettings: DrawingObjectsController.prototype.getChartSettings,
		editChartDrawingObjects: DrawingObjectsController.prototype.editChartDrawingObjects,
		editChartCallback: DrawingObjectsController.prototype.editChartCallback,
	getSelectedSingleChart: DrawingObjectsController.prototype.getSelectedSingleChart,


    getPageSizesByDrawingObjects: function()
    {
        var aW = [], aH = [];
        var aBPages = [];
        var page_limits;
        if(this.selectedObjects.length > 0)
        {
            for(var i = 0; i < this.selectedObjects.length; ++i)
            {
                if(!aBPages[this.selectedObjects[i].selectStartPage])
                {
                    page_limits = this.document.Get_PageLimits(this.selectedObjects[i].selectStartPage);
                    aW.push(page_limits.XLimit);
                    aH.push(page_limits.YLimit);
                    aBPages[this.selectedObjects[i].selectStartPage] = true;
                }
            }
            return {W: Math.min.apply(Math, aW), H: Math.min.apply(Math, aH)};
        }
        page_limits = this.document.Get_PageLimits(0);
        return {W: page_limits.XLimit, H: page_limits.YLimit};
    },

	AcceptRevisionChanges: function(Type, bAll)
    {
        var oDocContent = this.getTargetDocContent();
        if(oDocContent)
        {
            oDocContent.AcceptRevisionChanges(Type, bAll);
        }
    },


	RejectRevisionChanges: function(Type, bAll)
    {
        var oDocContent = this.getTargetDocContent();
        if(oDocContent)
        {
            oDocContent.RejectRevisionChanges(Type, bAll);
        }
    },

    Get_Props: function()
    {
        var props_by_types = DrawingObjectsController.prototype.getDrawingProps.call(this);
        var para_drawing_props = null;
        for(var i = 0; i < this.selectedObjects.length; ++i)
        {
            para_drawing_props = this.selectedObjects[i].parent.Get_Props(para_drawing_props);
        }
        var chart_props, shape_props, image_props;
        if(para_drawing_props)
        {
            if(props_by_types.shapeProps)
            {
                shape_props = new asc_CImgProperty(para_drawing_props);
                shape_props.ShapeProperties = AscFormat.CreateAscShapePropFromProp(props_by_types.shapeProps);
                shape_props.verticalTextAlign = props_by_types.shapeProps.verticalTextAlign;
                shape_props.vert = props_by_types.shapeProps.vert;
                shape_props.Width = props_by_types.shapeProps.w;
                shape_props.Height = props_by_types.shapeProps.h;
                shape_props.rot = props_by_types.shapeProps.rot;
                shape_props.flipH = props_by_types.shapeProps.flipH;
                shape_props.flipV = props_by_types.shapeProps.flipV;
                shape_props.lockAspect = props_by_types.shapeProps.lockAspect;
                if(this.selection.groupSelection){
                    shape_props.description = props_by_types.shapeProps.description;
                    shape_props.title = props_by_types.shapeProps.title;
                    shape_props.fromGroup = true;
                }
				if (para_drawing_props.Form) {
					shape_props.ShapeProperties.textArtProperties = null;
				}
            }
            if(props_by_types.imageProps)
            {
                image_props = new asc_CImgProperty(para_drawing_props);
                image_props.ImageUrl = props_by_types.imageProps.ImageUrl;
                image_props.isCrop = props_by_types.imageProps.isCrop;
                image_props.cropHeightCoefficient = props_by_types.imageProps.cropHeightCoefficient;
                image_props.cropWidthCoefficient = props_by_types.imageProps.cropWidthCoefficient;
                image_props.Width = props_by_types.imageProps.w;
                image_props.Height = props_by_types.imageProps.h;
                image_props.rot = props_by_types.imageProps.rot;
                image_props.flipH = props_by_types.imageProps.flipH;
                image_props.flipV = props_by_types.imageProps.flipV;
                image_props.lockAspect = props_by_types.imageProps.lockAspect;
                image_props.transparent = props_by_types.imageProps.transparent;

                image_props.pluginGuid = props_by_types.imageProps.pluginGuid;
                image_props.pluginData = props_by_types.imageProps.pluginData;

                if(this.selection.groupSelection){
                    image_props.description = props_by_types.imageProps.description;
                    image_props.title = props_by_types.imageProps.title;
                    image_props.fromGroup = true;
                }
            }
            if(props_by_types.chartProps && !(props_by_types.chartProps.severalCharts === true))
            {
                chart_props = new asc_CImgProperty(para_drawing_props);
                chart_props.ChartProperties = props_by_types.chartProps.chartProps;
                chart_props.severalCharts = props_by_types.chartProps.severalCharts;
                chart_props.severalChartStyles = props_by_types.chartProps.severalChartStyles;
                chart_props.severalChartTypes = props_by_types.chartProps.severalChartTypes;
                chart_props.lockAspect = props_by_types.chartProps.lockAspect;
                if(this.selection.groupSelection){
                    chart_props.description = props_by_types.chartProps.description;
                    chart_props.title = props_by_types.chartProps.title;
                    chart_props.fromGroup = true;
                }
            }
        }

        if(props_by_types.shapeProps)
        {
            var pr = props_by_types.shapeProps;
            if (pr.fill != null && pr.fill.fill != null && pr.fill.fill.type == Asc.c_oAscFill.FILL_TYPE_BLIP)
            {
                this.drawingDocument.DrawImageTextureFillShape(pr.fill.fill.RasterImageId);
            }
            else
            {
                this.drawingDocument.DrawImageTextureFillShape(null);
            }
        }
        else
        {
            this.drawingDocument.DrawImageTextureFillShape(null);
        }
        var ret = [];
        if(isRealObject(shape_props))
        {
            ret.push(shape_props);
        }
        if(isRealObject(image_props))
        {
            ret.push(image_props);
        }

        if(isRealObject(chart_props))
        {
            ret.push(chart_props);
        }
        return ret;
    },

    resetTextSelection: DrawingObjectsController.prototype.resetTextSelection,

    setProps: function(oProps)
    {
        var oApplyProps, i;

        for(i = 0; i < this.selectedObjects.length; ++i)
        {
            this.selectedObjects[i].parent.Set_Props(oProps);
        }

        oApplyProps = oProps;
        if(oProps.ShapeProperties)
        {
            oApplyProps = oProps.ShapeProperties;
            if(AscFormat.isRealBool(oProps.lockAspect))
            {
                oApplyProps.lockAspect = oProps.lockAspect;
            }
            if(AscFormat.isRealNumber(oProps.Width))
            {
                oApplyProps.Width = oProps.Width;
            }
            if(AscFormat.isRealNumber(oProps.Height))
            {
                oApplyProps.Height = oProps.Height;
            }
            if(AscFormat.isRealNumber(oProps.rot))
            {
                oApplyProps.rot = oProps.rot;
            }
            if(AscFormat.isRealBool(oProps.flipH))
            {
                oApplyProps.flipH = oProps.flipH;
            }
            if(AscFormat.isRealBool(oProps.flipV))
            {
                oApplyProps.flipV = oProps.flipV;
            }
            if(AscFormat.isRealBool(oProps.flipHInvert))
            {
                oApplyProps.flipHInvert = oProps.flipHInvert;
            }
            if(AscFormat.isRealBool(oProps.flipVInvert))
            {
                oApplyProps.flipVInvert = oProps.flipVInvert;
            }
        }
        this.applyDrawingProps(oApplyProps);
        if(AscFormat.isRealNumber(oApplyProps.Width) || AscFormat.isRealNumber(oApplyProps.Height) || AscFormat.isRealNumber(oApplyProps.rot)
            || AscFormat.isRealNumber(oApplyProps.rotAdd)
            || AscFormat.isRealBool(oApplyProps.flipH)|| AscFormat.isRealBool(oApplyProps.flipV)
            || AscFormat.isRealBool(oApplyProps.flipHInvert)|| AscFormat.isRealBool(oApplyProps.flipVInvert) || (typeof oApplyProps.type === "string")
            || AscCommon.isRealObject(oApplyProps.shadow) || oApplyProps.shadow === null || oApplyProps.bSetOriginalSize)
        {
            /*в случае если в насторойках ParaDrawing стоит UseAlign - пересчитываем drawing, т. к. ширина и высото ParaDrawing рассчитывается по bounds*/
            var aSelectedObjects = this.selectedObjects;
            for(i = 0; i < aSelectedObjects.length; ++i)
            {
                aSelectedObjects[i].parent.CheckWH();
            }
        }
        this.document.Recalculate();
        if(oApplyProps &&
            (oApplyProps.ChartProperties ||
            oApplyProps.textArtProperties && typeof oApplyProps.textArtProperties.asc_getForm() === "string" ||
            AscFormat.isRealNumber(oApplyProps.verticalTextAlign) ||
            AscFormat.isRealNumber(oApplyProps.vert))
        )
        {
            this.document.Document_UpdateSelectionState();
            this.document.RecalculateCurPos();
        }
    },

    applyDrawingProps: DrawingObjectsController.prototype.applyDrawingProps,
    updateConnectors: function (bMoveFlag) {},
    sendCropState: DrawingObjectsController.prototype.sendCropState,

    CheckAutoFit : function()
    {
        for(var i = this.drawingObjects.length - 1; i > -1; --i)
        {
                this.drawingObjects[i].CheckGroupSizes();
        }
    },

    checkUseDrawings: function(aDrawings)
    {
        for(var i = aDrawings.length - 1; i > -1; --i)
        {
            if(!aDrawings[i].IsUseInDocument())
            {
                aDrawings.splice(i, 1);
            }
        }
    },

    bringToFront : function()//перемещаем заселекченые объекты наверх
    {
        if(false === this.document.Document_Is_SelectionLocked(changestype_Drawing_Props))
        {
            this.document.StartAction(AscDFH.historydescription_Document_GrObjectsBringToFront);
            if(this.selection.groupSelection)
            {
                this.selection.groupSelection.bringToFront();
            }
            else
            {
                var aSelectedObjectsCopy = [], i;
                for(i = 0; i < this.selectedObjects.length; ++i)
                {
                    aSelectedObjectsCopy.push(this.selectedObjects[i].parent);
                }
                aSelectedObjectsCopy.sort(ComparisonByZIndexSimple);
                for(i = 0; i < aSelectedObjectsCopy.length; ++i)
                {
                    aSelectedObjectsCopy[i].Set_RelativeHeight(this.getZIndex());
                }
            }
            this.document.Recalculate();
            this.document.UpdateUndoRedo();
            this.document.FinalizeAction();
        }
    },

    checkZIndexMap: function(oDrawing, oDrawingMap, nNewZIndex)
    {
        if(!isRealObject(oDrawingMap[oDrawing.Get_Id()]))
        {
            oDrawingMap[oDrawing.Get_Id()] = oDrawing.RelativeHeight;
        }
        oDrawing.Set_RelativeHeight2(nNewZIndex);
    },

    insertBetween: function(aToInsert/*массив в котрый вставляем*/, aDrawings/*массив куда вставляем*/, nPos, oDrawingMap)
    {
        if(nPos > aDrawings.length || nPos < 0)
            return;
        var i, j, nBetweenMin, nBetweenMax, nTempInterval, aTempDrawingsArray, nDelta;
        if(nPos === aDrawings.length)
        {
            for(i = 0; i < aToInsert.length; ++i)
            {
                this.checkZIndexMap(aToInsert[i], oDrawingMap, this.getZIndex());
                aDrawings.push(aToInsert[i]);
            }
        }
        else
        {
            if(nPos > 0)
            {
                nBetweenMin = aDrawings[nPos-1].RelativeHeight;
            }
            else
            {
                nBetweenMin = -1;
            }
            nBetweenMax = aDrawings[nPos].RelativeHeight;
            if(aToInsert.length < nBetweenMax - nBetweenMin)//интервала хватает для вставки
            {
                for(i = 0; i < aToInsert.length; ++i)
                {
                    nBetweenMin += ((nBetweenMax - nBetweenMin)/(aToInsert.length + 1 - i)) >> 0;
                    this.checkZIndexMap(aToInsert[i], oDrawingMap, nBetweenMin);
                    aDrawings.splice(nPos + i, aToInsert[i]);
                }
            }
            else
            {
                nDelta =  nBetweenMax - nBetweenMin - aToInsert.length + 1; //сколько нам не хватает для вставки
                for(i = nPos; i < aDrawings.length; ++i)
                {
                    this.checkZIndexMap(aDrawings[i], oDrawingMap, aDrawings[i].RelativeHeight + nDelta);
                    if(i < aDrawings.length - 1)
                    {
                        if(aDrawings[i].RelativeHeight <= aDrawings[i+1].RelativeHeight)
                        {
                            break;
                        }
                    }
                }
                for(i = 0; i < aToInsert.length; ++i)
                {
                    this.checkZIndexMap(aToInsert[i], oDrawingMap, nBetweenMin+i);
                    aDrawings.splice(nPos + i, aToInsert[i]);
                }
            }
        }
    },

    checkDrawingsMap: function(oDrawingMap)
    {
        var aDrawings = [], oDrawing, aZIndex = [];
        for(var key in oDrawingMap)
        {
            if(oDrawingMap.hasOwnProperty(key))
            {
                oDrawing = AscCommon.g_oTableId.Get_ById(key);
                aDrawings.push(oDrawing);
                aZIndex.push(oDrawing.RelativeHeight);
                oDrawing.Set_RelativeHeight2(oDrawingMap[key]);
            }
        }
        return {aDrawings: aDrawings, aZIndex: aZIndex};
    },

    applyZIndex: function(oDrawingObject)
    {
        var aDrawings = oDrawingObject.aDrawings, aZIndex = oDrawingObject.aZIndex;
        for(var i = 0; i < aDrawings.length; ++i)
        {
            aDrawings[i].Set_RelativeHeight(aZIndex[i]);
        }
    },

    bringForward : function()//перемещаем заселекченные объекты на один уровень выше
    {
        if(this.selection.groupSelection)
        {
            if(false === this.document.Document_Is_SelectionLocked(changestype_Drawing_Props))
            {
                this.document.StartAction(AscDFH.historydescription_Document_GrObjectsBringForwardGroup);
                this.selection.groupSelection.bringForward();
                this.document.Recalculate();
                this.document.UpdateUndoRedo();
                this.document.FinalizeAction();
            }
        }
        else
        {
            var aDrawings = [].concat(this.drawingObjects), i, j, aSelect = [], nIndexLastNoSelect = -1, oDrawingsMap = {};
            this.checkUseDrawings(aDrawings);
            aDrawings.sort(ComparisonByZIndexSimple);
            for(i = aDrawings.length - 1; i > -1; --i)
            {
                if(aDrawings[i].GraphicObj.selected)
                {
                    if(nIndexLastNoSelect !== -1)
                    {
                        for(j = i; j > -1; --j)
                        {
                            if(aDrawings[j].GraphicObj.selected)
                            {
                                aSelect.splice(0, 0, aDrawings.splice(j, 1)[0]);
                                --nIndexLastNoSelect;
                            }
                            else
                            {
                                break;
                            }
                        }
                        this.insertBetween(aSelect, aDrawings, nIndexLastNoSelect + 1, oDrawingsMap);
                        aSelect.length = 0;
                        nIndexLastNoSelect = -1;
                        i = j+1;
                    }
                }
                else
                {
                    nIndexLastNoSelect = i;
                }
            }
            var oCheckObject = this.checkDrawingsMap(oDrawingsMap);
            if(false === this.document.Document_Is_SelectionLocked(AscCommon.changestype_None, {Type: changestype_2_ElementsArray_and_Type, CheckType: changestype_Drawing_Props, Elements:oCheckObject.aDrawings}))
            {
                this.document.StartAction(AscDFH.historydescription_Document_GrObjectsBringForward);
                this.applyZIndex(oCheckObject);
                this.document.Recalculate();
                this.document.UpdateUndoRedo();
                this.document.FinalizeAction();
            }
        }
    },

    sendToBack : function()
    {
        if(this.selection.groupSelection)
        {
            if(false === this.document.Document_Is_SelectionLocked(changestype_Drawing_Props))
            {
                this.document.StartAction(AscDFH.historydescription_Document_GrObjectsSendToBackGroup);
                this.selection.groupSelection.sendToBack();
                this.document.Recalculate();
                this.document.UpdateUndoRedo();
                this.document.FinalizeAction();
            }
        }
        else
        {
            var aDrawings = [].concat(this.drawingObjects), i, aSelect = [], oDrawingsMap = {};
            this.checkUseDrawings(aDrawings);
            aDrawings.sort(ComparisonByZIndexSimple);
            for(i = 0; i < aDrawings.length; ++i)
            {
                if(aDrawings[i].GraphicObj.selected)
                {
                    aSelect.push(aDrawings.splice(i, 1)[0]);
                }
            }
            this.insertBetween(aSelect, aDrawings, 0, oDrawingsMap);
            var oCheckObject = this.checkDrawingsMap(oDrawingsMap);
            if(false === this.document.Document_Is_SelectionLocked(AscCommon.changestype_None, {Type: changestype_2_ElementsArray_and_Type, CheckType: changestype_Drawing_Props, Elements:oCheckObject.aDrawings}))
            {
                this.document.StartAction(AscDFH.historydescription_Document_GrObjectsSendToBack);
                this.applyZIndex(oCheckObject);
                this.document.Recalculate();
                this.document.UpdateUndoRedo();
                this.document.FinalizeAction();
            }
        }
    },

    bringBackward : function()
    {
        if(this.selection.groupSelection)
        {
            if(false === this.document.Document_Is_SelectionLocked(changestype_Drawing_Props, {Type : changestype_2_ElementsArray_and_Type , Elements : [this.selection.groupSelection.parent.Get_ParentParagraph()], CheckType : AscCommon.changestype_Paragraph_Content}))
            {
                this.document.StartAction(AscDFH.historydescription_Document_GrObjectsBringBackwardGroup);
                this.selection.groupSelection.bringBackward();
                this.document.Recalculate();
                this.document.UpdateUndoRedo();
                this.document.FinalizeAction();
            }
        }
        else
        {
            var aDrawings = [].concat(this.drawingObjects), i, j, aSelect = [], nIndexLastNoSelect = -1, oDrawingsMap = {};
            this.checkUseDrawings(aDrawings);
            aDrawings.sort(ComparisonByZIndexSimple);
            for(i = 0; i < aDrawings.length; ++i)
            {
                if(aDrawings[i].GraphicObj.selected)
                {
                    if(nIndexLastNoSelect !== -1)
                    {
                        for(j = i; j < aDrawings.length; ++j)
                        {
                            if(aDrawings[j].GraphicObj.selected)
                            {
                                aSelect.push(aDrawings.splice(j, 1)[0]);
                            }
                            else
                            {
                                break;
                            }
                        }

                        this.insertBetween(aSelect, aDrawings, nIndexLastNoSelect, oDrawingsMap);
                        aSelect.length = 0;
                        nIndexLastNoSelect = -1;
                        i = j-1;
                    }
                }
                else
                {
                    nIndexLastNoSelect = i;
                }
            }
            var oCheckObject = this.checkDrawingsMap(oDrawingsMap);
            if(false === this.document.Document_Is_SelectionLocked(AscCommon.changestype_None, {Type: changestype_2_ElementsArray_and_Type, CheckType: changestype_Drawing_Props, Elements:oCheckObject.aDrawings}))
            {
                this.document.StartAction(AscDFH.historydescription_Document_GrObjectsBringBackward);
                this.applyZIndex(oCheckObject);
                this.document.Recalculate();
                this.document.UpdateUndoRedo();
                this.document.FinalizeAction();
            }
        }
    },

	getSingleSelectedChart: function ()
	{
		const arrByTypes = AscFormat.getObjectsByTypesFromArr(this.selectedObjects, true);
		const arrSelectedCharts = [];

		for(let i = 0; i < arrByTypes.charts.length; ++i)
		{
			if(arrByTypes.charts[i].selected)
			{
				arrSelectedCharts.push(arrByTypes.charts[i]);
			}
		}
		if (arrSelectedCharts.length === 1)
		{
			return arrSelectedCharts[0];
		}
		return null;
	},

    editChart: function(oBinary)
    {
        var chart_space = this.getChartSpace2(oBinary, null), select_start_page;

				const oSelectedChart  = this.getSingleSelectedChart();
        if(oSelectedChart)
        {
	        if (!oSelectedChart.isExternal() && oBinary["workbookBinary"])
	        {
						const oApi = this.getEditorApi();
		        chart_space.setXLSX(oApi.frameManager.getDecodedArray(oBinary["workbookBinary"]));
	        }
	        if (oBinary['imagesForAddToHistory'])
	        {
		        AscDFH.addImagesFromFrame(chart_space, oBinary['imagesForAddToHistory']);
	        }
            if(oSelectedChart.group)
            {
                var parent_group = oSelectedChart.group;
                var major_group = oSelectedChart.getMainGroup();
                for(var i = parent_group.spTree.length -1; i > -1; --i)
                {
                    if(parent_group.spTree[i] === oSelectedChart)
                    {
                        parent_group.removeFromSpTreeByPos(i);
                        chart_space.setGroup(parent_group);
                        chart_space.spPr.xfrm.setOffX(oSelectedChart.spPr.xfrm.offX);
                        chart_space.spPr.xfrm.setOffY(oSelectedChart.spPr.xfrm.offY);
                        parent_group.addToSpTree(i, chart_space);
                        major_group.updateCoordinatesAfterInternalResize();
                        major_group.parent.CheckWH();
                        if(this.selection.groupSelection)
                        {
                            select_start_page = this.selection.groupSelection.selectedObjects[0].selectStartPage;
                            this.selection.groupSelection.resetSelection();
                            this.selection.groupSelection.selectObject(chart_space, select_start_page);
                        }
                        this.document.Recalculate();
                        this.document.Document_UpdateInterfaceState();
                        return;
                    }
                }
            }
            else
            {
                chart_space.spPr.xfrm.setOffX(0);
                chart_space.spPr.xfrm.setOffY(0);
                select_start_page = oSelectedChart.selectStartPage;
                chart_space.setParent(oSelectedChart.parent);
                oSelectedChart.parent.Set_GraphicObject(chart_space);
                this.resetSelection();
                this.selectObject(chart_space, select_start_page);
                oSelectedChart.parent.CheckWH();
                this.document.Recalculate();
                this.document.Document_UpdateInterfaceState();
            }
        }
    },
	loadChartData: function (bNeedRecalculate) {
		const oChart = this.getSingleSelectedChart();
		const oApi = this.getEditorApi();
		if (oChart && oApi) {
			oApi.frameManager.loadChartData(oChart);
			if (bNeedRecalculate) {
				oChart.handleUpdateType();
				const oRecalcData = new AscCommon.RecalcData();
				oRecalcData.Drawings.Map[oChart.Id] = oChart;
				this.document.RecalculateWithParams(oRecalcData);
			}
		}
	},
	updateChart: function (binary)
	{
		const oSelectedChart = this.getSingleSelectedChart();
		if (oSelectedChart)
		{
			const oApi = this.getEditorApi();
			oApi.frameManager.saveChartData(oSelectedChart);
			const oChartInfo = this.getChartInfo(binary);
			const oChart = oChartInfo.chart;
			const oChartData = oChartInfo.chartData;
			oSelectedChart.setChart(oChart);
			if (oChartData) {
				oSelectedChart.setChartData(oChartData);
			}
			oSelectedChart.handleUpdateType();
      const oRecalcData = new AscCommon.RecalcData();
			oRecalcData.Drawings.Map[oSelectedChart.Id] = oSelectedChart;
			this.document.RecalculateWithParams(oRecalcData);
		}
	},


	getCompatibilityMode: function(){
        var ret = 0xFF;
        if(this.document && this.document.GetCompatibilityMode){
            ret = this.document.GetCompatibilityMode();
        }
        return ret;
    },


    mergeDrawings: function(pageIndex, HeaderDrawings, HeaderTables, FooterDrawings, FooterTables)
    {
        var nCompatibilityMode = this.getCompatibilityMode();
        if(!this.graphicPages[pageIndex])
        {
            this.graphicPages[pageIndex] = new CGraphicPage(pageIndex, this);
        }
        var drawings = [], tables = [], i, hdr_ftr_page = this.graphicPages[pageIndex].hdrFtrPage;
        if(HeaderDrawings)
        {
            drawings = drawings.concat(HeaderDrawings);
        }
        if(FooterDrawings)
        {
            drawings = drawings.concat(FooterDrawings);
        }

        var getFloatObjects = function(arrObjects)
        {
            var  ret = [];
            for(var i = 0; i < arrObjects.length; ++i)
            {
                if(arrObjects[i].IsParagraph())
                {
                    var calc_frame = arrObjects[i].CalculatedFrame;
                    if(calc_frame.StartIndex === arrObjects[i].Index)
                    {
                        var FramePr = arrObjects[i].Get_FramePr();
                        var FrameDx = ( undefined === FramePr.HSpace ? 0 : FramePr.HSpace );
                        var FrameDy = ( undefined === FramePr.VSpace ? 0 : FramePr.VSpace );
                        ret.push(new CFlowParagraph(arrObjects[i], calc_frame.L2, calc_frame.T2, calc_frame.W2, calc_frame.H2, FrameDx, FrameDy, arrObjects[i].GetIndex(), calc_frame.FlowCount, FramePr.Wrap));
                    }
                }
                else if(arrObjects[i].IsTable())
                {
                	if (0 === arrObjects[i].GetRelativeStartPage())
                    	ret.push(new CFlowTable(arrObjects[i], 0));
                }
            }
            return ret;
        };
        if(HeaderTables)
        {
            tables = tables.concat(getFloatObjects(HeaderTables));
        }
        if(FooterTables)
        {
            tables = tables.concat(getFloatObjects(FooterTables));
        }

        hdr_ftr_page.clear();
        for(i = 0; i < drawings.length; ++i)
        {

            var cur_drawing = drawings[i];
            if(!cur_drawing.bNoNeedToAdd && cur_drawing.PageNum === pageIndex)
            {
                var drawing_array = null;
                var Type = cur_drawing.getDrawingArrayType();
                if(Type === DRAWING_ARRAY_TYPE_INLINE){
                    drawing_array = hdr_ftr_page.inlineObjects;
                }
                else if(Type === DRAWING_ARRAY_TYPE_BEHIND){
                    drawing_array = hdr_ftr_page.behindDocObjects;
                }
                else{
                    drawing_array = hdr_ftr_page.beforeTextObjects;
                }
                if(Array.isArray(drawing_array))
                {
                    drawing_array.push(drawings[i].GraphicObj);
                }
            }
        }
        for(i = 0; i < tables.length; ++i)
        {
            hdr_ftr_page.flowTables.push(tables[i]);
        }
        hdr_ftr_page.behindDocObjects.sort(ComparisonByZIndexSimpleParent);
        hdr_ftr_page.beforeTextObjects.sort(ComparisonByZIndexSimpleParent);
    },

    addFloatTable: function(table)
    {
        var hdr_ftr = table.Table.Parent.IsHdrFtr(true);
        if(!this.graphicPages[table.PageNum + table.PageController])
        {
            this.graphicPages[table.PageNum + table.PageController] = new CGraphicPage(table.PageNum + table.PageController, this);
        }

		if (!hdr_ftr)
		{
			this.graphicPages[table.PageNum + table.PageController].addFloatTable(table);
		}
		else
		{
			this.graphicPages[table.PageNum + table.PageController].hdrFtrPage.addFloatTable(table);
		}
    },

	updateFloatTable : function(table)
	{
		var hdr_ftr = table.Table.Parent.IsHdrFtr(true);

		if (!hdr_ftr && this.graphicPages[table.PageNum + table.PageController])
		{
			this.graphicPages[table.PageNum + table.PageController].updateFloatTable(table);
		}
	},

    removeFloatTableById: function(pageIndex, id)
    {
        if(!this.graphicPages[pageIndex])
        {
            this.graphicPages[pageIndex] = new CGraphicPage(pageIndex, this);
        }
        var table = AscCommon.g_oTableId.Get_ById(id);
        if(table)
        {
            var hdr_ftr = table.Parent.IsHdrFtr(true);
            if(!hdr_ftr)
            {
                this.graphicPages[pageIndex].removeFloatTableById(id);
            }
        }
    },

    selectionIsTableBorder: function()
    {
        var content = this.getTargetDocContent();
        if(content)
            return content.IsMovingTableBorder();
        return false;
    },


    getTableByXY: function(x, y, pageIndex, documentContent)
    {
        if(!this.graphicPages[pageIndex])
        {
            this.graphicPages[pageIndex] = new CGraphicPage(pageIndex, this);
        }
        if(!documentContent.IsHdrFtr())
            return this.graphicPages[pageIndex].getTableByXY(x, y, documentContent);
        else
            return this.graphicPages[pageIndex].hdrFtrPage.getTableByXY(x, y, documentContent);
        return null;
    },

    OnMouseDown: function(e, x, y, pageIndex)
    {
        //console.log("down " + this.curState.id);
        this.checkInkState();
        this.curState.onMouseDown(e, x, y, pageIndex);
        if(this.arrTrackObjects.length === 0)
        {
            this.document.GetApi().sendEvent("asc_onSelectionEnd");
        }
    },

    OnMouseMove: function(e, x, y, pageIndex)
    {

        //console.log("move " + this.curState.id);
        this.curState.onMouseMove(e, x, y, pageIndex);
    },

    OnMouseUp: function(e, x, y, pageIndex)
    {

        //console.log("up " + this.curState.id);
        this.curState.onMouseUp(e, x, y, pageIndex);
    },

    draw: function(pageIndex, graphics)
    {
        this.graphicPages[pageIndex] && this.graphicPages[pageIndex].draw(graphics);
    },

    selectionDraw: function()
    {
        this.drawingDocument.m_oWordControl.OnUpdateOverlay();
    },

    updateOverlay: function()
    {
        this.drawingDocument.m_oWordControl.OnUpdateOverlay();
    },

    isPolylineAddition: function()
    {
        return this.curState.polylineFlag === true;
    },

    shapeApply: function(props)
    {
        this.applyDrawingProps(props);
    },


    addShapeOnPage: function(sPreset, nPageIndex)
    {
        if ( docpostype_HdrFtr !== this.document.GetDocPosType() || null !== this.document.HdrFtr.CurHdrFtr )
        {
            if (docpostype_HdrFtr !== this.document.GetDocPosType())
            {
                this.document.SetDocPosType(docpostype_DrawingObjects);
                this.document.Selection.Use   = true;
                this.document.Selection.Start = true;
            }
            else
            {
                this.document.Selection.Use   = true;
                this.document.Selection.Start = true;

                var CurHdrFtr = this.document.HdrFtr.CurHdrFtr;
                var DocContent = CurHdrFtr.Content;

                DocContent.SetDocPosType(docpostype_DrawingObjects);
                DocContent.Selection.Use   = true;
                DocContent.Selection.Start = true;
            }

            var dX, dY, dExtX, dExtY;
            var oSectPr = this.document.Get_PageLimits(nPageIndex);
            var oExt = AscFormat.fGetDefaultShapeExtents(sPreset);
            var dSize = Math.min(oSectPr.XLimit / 2, oSectPr.YLimit / 2);
            var dScale = dSize/Math.max(oExt.x, oExt.y);
            dExtX = oExt.x * dScale;
            dExtY = oExt.y * dScale;
            dX = (oSectPr.XLimit - oSectPr.X - dExtX) / 2;
            dX = Math.max(0, dX);
            dY = (oSectPr.YLimit - oSectPr.Y - dExtY) / 2;
            dY = Math.max(0, dY);
            this.changeCurrentState(new AscFormat.StartAddNewShape(this, sPreset));
            this.OnMouseDown({}, dX, dY, nPageIndex);
            if(AscFormat.isRealNumber(dExtX) && AscFormat.isRealNumber(dExtY))
            {
                this.OnMouseMove({IsLocked: true}, dX + dExtX, dY + dExtY, nPageIndex)
            }
            this.OnMouseUp({}, dX, dY, nPageIndex);
            this.document.Document_UpdateInterfaceState();
            this.document.Document_UpdateRulersState();
            this.document.Document_UpdateSelectionState();
        }
    },


    drawOnOverlay: function(overlay)
    {
        var _track_objects = this.arrTrackObjects;
        var _object_index;
        var _object_count = _track_objects.length;
        for(_object_index = 0; _object_index < _object_count; ++_object_index)
        {
            _track_objects[_object_index].draw(overlay);
        }
        if(this.curState.InlinePos)
        {
            this.drawingDocument.AutoShapesTrack.SetCurrentPage(this.curState.InlinePos.Page);
            this.drawingDocument.AutoShapesTrack.DrawInlineMoveCursor(this.curState.InlinePos.X, this.curState.InlinePos.Y, this.curState.InlinePos.Height, this.curState.InlinePos.transform);
        }
        //TODO Anchor Position
        return;
    },


	getAllDrawingsOnPage: function(pageIndex, bHdrFtr)
	{
		if(!this.graphicPages[pageIndex])
			this.graphicPages[pageIndex] = new CGraphicPage(pageIndex, this);
		var arr, page, i, ret = [];
		if(!bHdrFtr)
		{

			page = this.graphicPages[pageIndex];
		}
		else
		{
			page = this.graphicPages[pageIndex].hdrFtrPage;
		}
		arr = page.behindDocObjects.concat(page.beforeTextObjects);
		return arr;
	},

	getDrawingObjects: function(pageIndex)
	{
		let bHdrFtr = false;
		if(this.document && this.document.GetDocPosType() === AscCommonWord.docpostype_HdrFtr)
		{
			bHdrFtr = true;
		}
		return this.getAllDrawingsOnPage(pageIndex, bHdrFtr);
	},

    getAllFloatObjectsOnPage: function(pageIndex, docContent)
    {
        if(!this.graphicPages[pageIndex])
            this.graphicPages[pageIndex] = new CGraphicPage(pageIndex, this);
        var arr, page, i, ret = [];
        arr = this.getAllDrawingsOnPage(pageIndex, docContent.IsHdrFtr());
        for(i = 0; i < arr.length; ++i)
        {
            if(arr[i].parent && arr[i].parent.GetDocumentContent() === docContent)
            {
                ret.push(arr[i].parent);
            }
        }
        return ret;
    },

    getAllFloatTablesOnPage: function(pageIndex, docContent)
    {
        if(!this.graphicPages[pageIndex])
            this.graphicPages[pageIndex] = new CGraphicPage(pageIndex, this);
        if(!docContent)
        {
            docContent = this.document;
        }

        var tables, page;
        if(!docContent.IsHdrFtr())
        {

            page = this.graphicPages[pageIndex];
        }
        else
        {
            page = this.graphicPages[pageIndex].hdrFtrPage;
        }
        tables = page.flowTables;
        var ret = [];
        for(var i = 0; i < tables.length; ++i)
        {
            if(tables[i].IsFlowTable() && tables[i].Table.Parent === docContent)
                ret.push(tables[i]);
        }
        return ret;
    },

    getTargetDocContent: DrawingObjectsController.prototype.getTargetDocContent,
    getTextArtPreviewManager: DrawingObjectsController.prototype.getTextArtPreviewManager,
    getEditorApi: DrawingObjectsController.prototype.getEditorApi,
    resetConnectors: DrawingObjectsController.prototype.resetConnectors,
    checkDlblsPosition: DrawingObjectsController.prototype.checkDlblsPosition,
    resetChartElementsSelection: DrawingObjectsController.prototype.resetChartElementsSelection,
    checkCurrentTextObjectExtends: DrawingObjectsController.prototype.checkCurrentTextObjectExtends,

		openChartEditor: function ()
		{
				const oChart = this.getChartObject();
				if (oChart)
				{
					const oChartLoader = new AscCommon.CFrameDiagramBinaryLoader(oChart);
					oChartLoader.tryOpen();
				}
		},

    handleChartDoubleClick: function(drawing, chart, e, x, y, pageIndex)
    {
	    const oApi = this.getEditorApi();
	    if(oApi && !oApi.isOpenedFrameEditor && false === this.document.Document_Is_SelectionLocked(changestype_Drawing_Props))
	    {
		    this.openChartEditor(chart);
		    this.clearTrackObjects();
		    this.clearPreTrackObjects();
		    this.changeCurrentState(new AscFormat.NullState(this));
		    this.document.OnMouseUp(e, x, y, pageIndex);
	    }
    },

	openOleEditor: function ()
	{
			const oOleObject = this.canEditTableOleObject(true);
			if (oOleObject)
			{
				const oleLoader = new AscCommon.CFrameOleBinaryLoader(oOleObject);
				oleLoader.tryOpen();
			}
	},

    handleSignatureDblClick: function(sGuid, width, height){
        editor.sendEvent("asc_onSignatureDblClick", sGuid, width, height);
    },


    handleOleObjectDoubleClick: function(drawing, oleObject, e, x, y, pageIndex)
    {
        if (false === this.document.Document_Is_SelectionLocked(changestype_Drawing_Props) || !this.document.CanEdit()) {
            if(drawing && drawing.ParaMath){
                editor.sync_OnConvertEquationToMath(drawing);
            }
            else if (oleObject.canEditTableOleObject())
            {
	            this.openOleEditor();
            }
            else
            {
                oleObject.runPlugin();
            }
            this.clearTrackObjects();
            this.clearPreTrackObjects();
            this.changeCurrentState(new AscFormat.NullState(this));
            this.document.OnMouseUp(e, x, y, pageIndex);
        }
    },

    startEditCurrentOleObject: function()
    {
        let aSelectedObjects = this.getSelectedArray();
        if(aSelectedObjects.length === 1 && aSelectedObjects[0].isOleObject())
        {
            let oleObject = aSelectedObjects[0];
            if(!this.document.IsSelectionLocked(changestype_Drawing_Props))
            {
                oleObject.runPlugin();
            }
        }
    },

    handleMathDrawingDoubleClick : function(drawing, e, x, y, pageIndex)
    {
		editor.sync_OnConvertEquationToMath(drawing);
        this.changeCurrentState(new AscFormat.NullState(this));
        this.document.OnMouseUp(e, x, y, pageIndex);
    },

    addInlineImage: function( W, H, Img, GraphicObject, bFlow )
    {
        var content = this.getTargetDocContent();
        if(content)
        {
            if(!content.bPresentation){
                content.AddInlineImage(W, H, Img, GraphicObject, bFlow );
            }
            else{
                if(this.selectedObjects.length > 0)
                {
                    this.resetSelection2();
                    this.document.AddInlineImage(W, H, Img, GraphicObject, bFlow );
                }
            }
        }
        else
        {
            if(this.selectedObjects.length > 0)
            {
                this.resetSelection2();
                this.document.AddInlineImage(W, H, Img, GraphicObject, bFlow );
            }
        }
    },

    addSignatureLine: function(oSignatureDrawing)
    {
        var content = this.getTargetDocContent();
        if(content)
        {
            if(!content.bPresentation){
                content.AddSignatureLine(oSignatureDrawing);
            }
            else{
                if(this.selectedObjects.length > 0)
                {
                    this.resetSelection2();
                    this.document.AddSignatureLine(oSignatureDrawing);
                }
            }
        }
        else
        {
            if(this.selectedObjects[0] && this.selectedObjects[0].parent && this.selectedObjects[0].parent.Is_Inline())
            {
                this.resetInternalSelection();
                this.document.Remove(1, true);
                this.document.AddSignatureLine(oSignatureDrawing);
            }
            else
            {
                if(this.selectedObjects.length > 0)
                {
                    this.resetSelection2();
                    this.document.AddSignatureLine(oSignatureDrawing);
                }
            }
        }
    },

    getDrawingArray: function()
    {
        var ret = [];
        var arrDrawings = [].concat(this.drawingObjects);
        this.checkUseDrawings(arrDrawings);
        for(var i = 0; i < arrDrawings.length; ++i) {
            if(arrDrawings[i] && arrDrawings[i].GraphicObj && !arrDrawings[i].GraphicObj.bDeleted){
                ret.push(arrDrawings[i].GraphicObj);
            }
        }
        return ret;
    },

    getAllSignatures: AscFormat.DrawingObjectsController.prototype.getAllSignatures,

    getAllSignatures2: AscFormat.DrawingObjectsController.prototype.getAllSignatures2,

    addOleObject: function(W, H, nWidthPix, nHeightPix, Img, Data, sApplicationId, bSelect, arrImagesForAddToHistory)
    {
        let content = this.getTargetDocContent();
		let oDrawing = null;
        if(content)
        {
            if(!content.bPresentation){
	            oDrawing = content.AddOleObject(W, H, nWidthPix, nHeightPix, Img, Data, sApplicationId, bSelect, arrImagesForAddToHistory);
            }
            else{
                if(this.selectedObjects.length > 0)
                {
                    this.resetSelection2();
	                oDrawing = this.document.AddOleObject(W, H, nWidthPix, nHeightPix, Img, Data, sApplicationId, bSelect, arrImagesForAddToHistory);
                }
            }
        }
        else
        {
            if(this.selectedObjects[0] && this.selectedObjects[0].parent && this.selectedObjects[0].parent.Is_Inline())
            {
                this.resetInternalSelection();
                this.document.Remove(1, true);
	            oDrawing = this.document.AddOleObject(W, H, nWidthPix, nHeightPix, Img, Data, sApplicationId, bSelect, arrImagesForAddToHistory);
            }
            else
            {
                if(this.selectedObjects.length > 0)
                {
                    this.resetSelection2();
	                oDrawing = this.document.AddOleObject(W, H, nWidthPix, nHeightPix, Img, Data, sApplicationId, bSelect, arrImagesForAddToHistory);
                }
            }
        }
		return oDrawing;
    },

	addInlineTable : function(nCols, nRows, nMode)
	{
		var content = this.getTargetDocContent();
		if (content)
		{
			return content.AddInlineTable(nCols, nRows, nMode);
		}

		return null;
	},

    addImages: function( aImages )
    {
        var content = this.getTargetDocContent();
        if(content && !content.bPresentation)
        {
            content.AddImages(aImages);
        }
        else{
			if(this.selectedObjects.length === 0)
			{
				if(this.resetDrawStateBeforeAction())
				{
					this.document.AddImages(aImages);
				}
			}
			else
			{
				this.resetSelection2();
				this.document.AddImages(aImages);
			}
        }
    },


    canAddComment: function()
    {
        var content = this.getTargetDocContent();
        return content && content.CanAddComment();
    },

    addComment: function(commentData)
    {
        var content = this.getTargetDocContent();
        return content && content.AddComment(commentData, true, true);
    },

    hyperlinkCheck: DrawingObjectsController.prototype.hyperlinkCheck,

    hyperlinkCanAdd: DrawingObjectsController.prototype.hyperlinkCanAdd,

    hyperlinkRemove: DrawingObjectsController.prototype.hyperlinkRemove,

    hyperlinkModify: DrawingObjectsController.prototype.hyperlinkModify,

    hyperlinkAdd: DrawingObjectsController.prototype.hyperlinkAdd,

    isCurrentElementParagraph: function()
    {
        var content = this.getTargetDocContent();
        return content && content.Is_CurrentElementParagraph();
    },
    isCurrentElementTable: function()
    {
        var content = this.getTargetDocContent();
        return content && content.Is_CurrentElementTable();
    },

    getColumnSize: function() 
    {
        var oTargetTexObject = AscFormat.getTargetTextObject(this);
        if(oTargetTexObject && oTargetTexObject.getObjectType() === AscDFH.historyitem_type_Shape) 
        {
            var oRect = oTargetTexObject.getTextRect();
            if(oRect) 
            {
                var oBodyPr = oTargetTexObject.getBodyPr();
                var l_ins = AscFormat.isRealNumber(oBodyPr.lIns) ? oBodyPr.lIns : 2.54;
                var t_ins = AscFormat.isRealNumber(oBodyPr.tIns) ? oBodyPr.tIns : 1.27;
                var r_ins = AscFormat.isRealNumber(oBodyPr.rIns) ? oBodyPr.rIns : 2.54;
                var b_ins = AscFormat.isRealNumber(oBodyPr.bIns) ? oBodyPr.bIns : 1.27;
                var dW = oRect.r - oRect.l - (l_ins + r_ins);
                var dH = oRect.b - oRect.t - (t_ins + b_ins);
                if(dW > 0 && dH > 0) 
                {
                    return {
                        W : dW,
                        H : dH
                    };
                }
            }
        }
        return {
            W : AscCommon.Page_Width - (AscCommon.X_Left_Margin + AscCommon.X_Right_Margin),
            H : AscCommon.Page_Height - (AscCommon.Y_Top_Margin + AscCommon.Y_Bottom_Margin)
        };
    },

	GetSelectedContent : function(SelectedContent)
    {
        var content = this.getTargetDocContent();
        if(content)
        {
            content.GetSelectedContent(SelectedContent);
        }
        else
        {
            var para = new AscWord.Paragraph();
            var selectedObjects, run, drawing, i;
            var aDrawings = [];
            if(this.selection.groupSelection)
            {
                selectedObjects = this.selection.groupSelection.selectedObjects;
                var groupParaDrawing = this.selection.groupSelection.parent;
                //TODO: в случае инлановой группы для определения позиции нужно чтобы докуметн был рассчитан. Не понятно можно ли использовать рассчитаные позиции. Пока создаем инлайновые ParaDrawing.
                for(i = 0; i < selectedObjects.length; ++i)
                {
                    run =  new ParaRun(para, false);

					var oRunPr = selectedObjects[i].parent && selectedObjects[i].parent.GetRun() ? selectedObjects[i].parent.GetRun().GetDirectTextPr() : null;
					if (oRunPr)
						run.SetPr(oRunPr.Copy());

                    selectedObjects[i].recalculate();
                    var oGraphicObj = selectedObjects[i].copy();
                    if(this.selection.groupSelection.getObjectType() === AscDFH.historyitem_type_SmartArt)
                    {
                        oGraphicObj = oGraphicObj.convertFromSmartArt();
                        if(oGraphicObj.getObjectType() === AscDFH.historyitem_type_Shape)
                        {
                            oGraphicObj = oGraphicObj.convertToWord(this.document);
                        }
                    }
                    drawing = new ParaDrawing(0, 0, oGraphicObj, this.document.DrawingDocument, this.document, null);
                    drawing.Set_DrawingType(groupParaDrawing.DrawingType);
                    drawing.GraphicObj.setParent(drawing);
                    if(drawing.GraphicObj.spPr && drawing.GraphicObj.spPr.xfrm && AscFormat.isRealNumber(drawing.GraphicObj.spPr.xfrm.offX) && AscFormat.isRealNumber(drawing.GraphicObj.spPr.xfrm.offY))
                    {
                        drawing.GraphicObj.spPr.xfrm.setOffX(0);
                        drawing.GraphicObj.spPr.xfrm.setOffY(0);
                    }
                    drawing.CheckWH();
                    if(groupParaDrawing.DrawingType === drawing_Anchor)
                    {
                        drawing.Set_Distance(groupParaDrawing.Distance.L, groupParaDrawing.Distance.T, groupParaDrawing.Distance.R, groupParaDrawing.Distance.B);
                        drawing.Set_WrappingType(groupParaDrawing.wrappingType);
                        drawing.Set_BehindDoc(groupParaDrawing.behindDoc);
                        drawing.Set_PositionH(groupParaDrawing.PositionH.RelativeFrom, groupParaDrawing.PositionH.Align, groupParaDrawing.PositionH.Value + selectedObjects[i].bounds.x, groupParaDrawing.PositionH.Percent);
                        drawing.Set_PositionV(groupParaDrawing.PositionV.RelativeFrom, groupParaDrawing.PositionV.Align, groupParaDrawing.PositionV.Value + selectedObjects[i].bounds.y, groupParaDrawing.PositionV.Percent);
                    }
                    run.Add_ToContent(run.State.ContentPos, drawing, true, false);
                    para.Internal_Content_Add(para.CurPos.ContentPos, run, true);
                    aDrawings.push(drawing);
                }
            }
            else
            {
                selectedObjects = this.selectedObjects;
                for(i = 0; i < selectedObjects.length; ++i)
                {
                    run =  new ParaRun(para, false);

					var oRunPr = selectedObjects[i].parent && selectedObjects[i].parent.GetRun() ? selectedObjects[i].parent.GetRun().GetDirectTextPr() : null;
					if (oRunPr)
						run.SetPr(oRunPr.Copy());

                    var oSp = selectedObjects[i];
                    var oDr = oSp.parent;
                    oSp.recalculate();
                    drawing = new ParaDrawing(0, 0, oSp.copy(), this.document.DrawingDocument, this.document, null);

                    drawing.Set_DrawingType(oDr.DrawingType);
                    if(oDr.Extent)
                    {
                        drawing.setExtent(oDr.Extent.W, oDr.Extent.H)
                    }
                    drawing.GraphicObj.setParent(drawing);
                    drawing.GraphicObj.setTransformParams(0, 0, oSp.extX, oSp.extY, oSp.rot, oSp.flipH, oSp.flipV);
                    //drawing.CheckWH();
					drawing.Set_ParaMath(oDr.ParaMath);
                    drawing.docPr.setFromOther(oDr.docPr);
					drawing.SetForm(oDr.IsForm());
                    if(oDr.DrawingType === drawing_Anchor)
                    {
                        drawing.Set_Distance(oDr.Distance.L, oDr.Distance.T, oDr.Distance.R, oDr.Distance.B);
                        drawing.Set_WrappingType(oDr.wrappingType);
                        drawing.Set_BehindDoc(oDr.behindDoc);
                        if(oDr.wrappingPolygon && drawing.wrappingPolygon)
                        {
                            drawing.wrappingPolygon.fromOther(oDr.wrappingPolygon);
                        }
                        drawing.Set_BehindDoc(oDr.behindDoc);
                        drawing.Set_RelativeHeight(oDr.RelativeHeight);
                        if(oDr.PositionH.Align){
                            drawing.Set_PositionH(oDr.PositionH.RelativeFrom, oDr.PositionH.Align, oDr.PositionH.Value, oDr.PositionH.Percent);
                        }
                        else{
                            drawing.Set_PositionH(oDr.PositionH.RelativeFrom, oDr.PositionH.Align, oDr.PositionH.Value + oSp.bounds.x, oDr.PositionH.Percent);
                        }

                        if(oDr.PositionV.Align){
                            drawing.Set_PositionV(oDr.PositionV.RelativeFrom, oDr.PositionV.Align, oDr.PositionV.Value, oDr.PositionV.Percent);
                        }
                        else{
                            drawing.Set_PositionV(oDr.PositionV.RelativeFrom, oDr.PositionV.Align, oDr.PositionV.Value + oSp.bounds.y, oDr.PositionV.Percent);
                        }
                    }
                    run.Add_ToContent(run.State.ContentPos, drawing, true, false);
                    para.Internal_Content_Add(para.CurPos.ContentPos, run, true);
                    aDrawings.push(drawing);
                }
            }
            var bSelectedAll = true;
            if(aDrawings.length === 1 && aDrawings[0].IsInline())
            {
                bSelectedAll = false;
            }
            SelectedContent.Add( new AscCommonWord.CSelectedElement( para, bSelectedAll ) );
        }
    },

    getCurrentPageAbsolute: function()
    {
        if(this.curState.majorObject)
        {
            return this.curState.majorObject.selectStartPage;
        }
        var selection_arr = this.selectedObjects;
        if(selection_arr[0].length > 0)
        {
            return selection_arr[0].selectStartPage;
        }
        return 0;
    },

    createGraphicPage: function(pageIndex)
    {
        if(!isRealObject(this.graphicPages[pageIndex]))
            this.graphicPages[pageIndex] = new CGraphicPage(pageIndex, this);
    },

	resetDrawingArrays : function(pageIndex, docContent)
	{
		var hdr_ftr = docContent.IsHdrFtr(true);
		if (!hdr_ftr)
		{
			if (isRealObject(this.graphicPages[pageIndex]))
			{
				this.graphicPages[pageIndex].resetDrawingArrays(docContent);
			}
		}
	},

	resetHdrFtrDrawingArrays : function(pageIndex)
	{
		let oPage = this.getHdrFtrObjectsByPageIndex(pageIndex);
		if (oPage)
			oPage.clear();
	},

    mergeHdrFtrPages: function(page1, page2, pageIndex)
    {
        if(!isRealObject(this.graphicPages[pageIndex]))
            this.graphicPages[pageIndex] = new CGraphicPage(pageIndex, this);
        this.graphicPages[pageIndex].hdrFtrPage.clear();
        this.graphicPages[pageIndex].hdrFtrPage.mergePages(page1, page2);
    },



    onEndRecalculateDocument: function(pagesCount)
    {
        for(var i = 0; i < pagesCount; ++i)
        {
            if(!isRealObject(this.graphicPages[i]))
                this.graphicPages[i] = new CGraphicPage(i, this);
        }
        if(this.graphicPages.length > pagesCount)
        {
            for(i = pagesCount; i < this.graphicPages.length; ++i)
                delete  this.graphicPages[i];
        }
    },


    documentStatistics: function( CurPage, Statistics )
    {
        if(this.graphicPages[CurPage])
        {
            this.graphicPages[CurPage].documentStatistics(Statistics);
        }
    },

    setSelectionState: function (state, stateIndex)
    {
        DrawingObjectsController.prototype.setSelectionState.call(this, state, stateIndex);
        let oState = state[stateIndex];
        if(!oState)
        {
            oState = state[state.length - 1];
        }
        if(oState)
        {
            if(oState.curState)
                this.curState = oState.curState;
            if(Array.isArray(oState.arrPreTrackObjects))
                this.arrPreTrackObjects = oState.arrPreTrackObjects;
            if(Array.isArray(oState.arrTrackObjects))
                this.arrTrackObjects = oState.arrTrackObjects;
        }
    },

    getSelectionState: DrawingObjectsController.prototype.getSelectionState,
    resetTrackState: DrawingObjectsController.prototype.resetTrackState,
    applyPropsToChartSpace: DrawingObjectsController.prototype.applyPropsToChartSpace,
	getAllowedDataLabelsPosition: DrawingObjectsController.prototype.getAllowedDataLabelsPosition,
	checkSingleChartSelection: DrawingObjectsController.prototype.checkSingleChartSelection,

    documentUpdateSelectionState: function()
    {
        if(this.selection.textSelection)
        {
            this.selection.textSelection.updateSelectionState();
        }
        else if(this.selection.groupSelection)
        {
            this.selection.groupSelection.documentUpdateSelectionState();
        }
        else if(this.selection.chartSelection)
        {
            this.selection.chartSelection.documentUpdateSelectionState();
        }
        else
        {
            this.drawingDocument.SelectClear();
            this.drawingDocument.TargetEnd();
			this.drawingDocument.SelectEnabled(true);
			this.drawingDocument.SelectShow();
        }
    },


    getMajorParaDrawing: function()
    {
		if(this.selectedObjects.length > 0)
		{
			return this.selectedObjects[0].parent;
		}
        if(this.lastSelectedObject)
        {
            let oParaDrawing = this.lastSelectedObject.parent;
            if(oParaDrawing && oParaDrawing.IsUseInDocument())
            {
                return oParaDrawing;
            }
        }
		return null;
    },

	resetDrawStateBeforeAction: function()
	{
		if(!this.document)
			return;
		if(!this.checkTrackDrawings())
			return;
		if(!this.document.IsDrawingSelected())
			return

		let bResult = !!this.startDocState;
		this.loadStartDocState();
		const oAPI = this.getEditorApi();
		oAPI.stopInkDrawer();
		return bResult;
	},

	loadStartDocState: function() {
		if(this.startDocState)
		{
			if(this.document)
			{
				this.document.LoadDocumentState(this.startDocState);
			}
			this.startDocState = null;
		}
	},

    documentUpdateRulersState: function()
    {
        var content = this.getTargetDocContent();
        if(content && content.Parent && content.Parent.getObjectType && content.Parent.getObjectType() === AscDFH.historyitem_type_Shape)
        {
            content.Parent.documentUpdateRulersState();
        }
       //else if(this.selectedObjects.length > 0)
       //{
       //    var parent_paragraph = this.selectedObjects[0].parent.Get_ParentParagraph();
       //    if(parent_paragraph)
       //    {
       //        parent_paragraph.Document_UpdateRulersState();
       //    }
       //}
    },


    updateTextPr: function()
    {
        var TextPr = this.getParagraphTextPr();
        if(TextPr)
        {
            var theme = this.document.Get_Theme();
            if(theme && theme.themeElements && theme.themeElements.fontScheme)
            {
                TextPr.ReplaceThemeFonts(theme.themeElements.fontScheme);
            }
            editor.UpdateTextPr(TextPr);
        }
    },

    updateParentParagraphParaPr : function()
    {
        let oDrawing = this.getMajorParaDrawing();
        if(oDrawing)
        {
            let oParagraph = oDrawing.Get_ParentParagraph();
            if(oParagraph)
            {
                let oParaPr = oParagraph.Get_CompiledPr2(true).ParaPr;
                if (oParaPr)
                {
                    editor.sync_ParaSpacingLine( oParaPr.Spacing );
                    editor.Update_ParaInd(oParaPr.Ind, oParaPr.Bidi);
                    editor.sync_PrAlignCallBack(oParaPr.Jc);
                    editor.sync_ParaStyleName(oParaPr.StyleName);
                }
            }
        }
    },

    documentUpdateInterfaceState: function()
    {
        if(this.selection.textSelection)
        {
            this.selection.textSelection.getDocContent().Document_UpdateInterfaceState();
        }
        else if(this.selection.groupSelection)
        {
            this.selection.groupSelection.documentUpdateInterfaceState();
        }
        else
        {
            var para_pr = DrawingObjectsController.prototype.getParagraphParaPr.call(this);
            if(!para_pr)
            {
                //if(this.selectedObjects[0] && this.selectedObjects[0].parent && this.selectedObjects[0].parent.Is_Inline())
                //{
                //    var parent_para = this.selectedObjects[0].parent.Get_ParentParagraph();
                //    if(parent_para)
                //        para_pr = parent_para.Get_CompiledPr2(true).ParaPr;
                //}
            }
            if(para_pr)
            {
                var TextPr = this.getParagraphTextPr();
                var theme = this.document.Get_Theme();
                if(theme && theme.themeElements && theme.themeElements.fontScheme)
                {
                    TextPr.ReplaceThemeFonts(theme.themeElements.fontScheme);
                }
                editor.UpdateParagraphProp(para_pr);
                editor.UpdateTextPr(TextPr);
            }
        }
    },

    resetInterfaceTextPr: function()
    {
       // var oTextPr =  new CTextPr();
       // oTextPr.Set_FromObject(
       //     {
       //         Bold: false,
       //         Italic: false,
       //         Underline: false,
       //         Strikeout: false,
       //         FontFamily:{
       //             Name : "", Index : -1
       //         },
       //         FontSize: null,
       //         VertAlign: null,
       //         HighLight: highlight_None,
       //         Spacing: null,
       //         DStrikeout: false,
       //         Caps: null,
       //         SmallCaps: null,
       //         Position: null,
       //         Lang: null
       //     }
       // );
       // editor.UpdateTextPr(oTextPr);
		editor.Update_ParaTab(AscCommonWord.Default_Tab_Stop, new CParaTabs());
        editor.sync_ParaSpacingLine( new CParaSpacing() );
        editor.Update_ParaInd(new CParaInd(), false);
        editor.sync_PrAlignCallBack(null);
        editor.sync_ParaStyleName(null);
    },

    isNeedUpdateRulers: function()
    {
        if(this.selectedObjects.length === 1 && this.selectedObjects[0].getDocContent && this.selectedObjects[0].getDocContent())
        {
            return true;
        }
        return false;
    },

    documentCreateFontCharMap: function( FontCharMap )
    {
        //ToDo
        return;
    },

    documentCreateFontMap: function( FontCharMap )
    {
        //TODO
        return;
    },

    tableCheckSplit: function()
    {
        var content = this.getTargetDocContent();
        return content && content.CanSplitTableCells();
    },

    tableCheckMerge: function()
    {
        var content = this.getTargetDocContent();
        return content && content.CanMergeTableCells();
    },

    tableSelect: function( Type )
    {
        var content = this.getTargetDocContent();
        return content && content.SelectTable(Type);
    },

    tableRemoveTable: function()
    {
        var content = this.getTargetDocContent();
        return content && content.RemoveTable();
    },

    tableSplitCell: function(Cols, Rows)
    {
        var content = this.getTargetDocContent();
        return content && content.SplitTableCells(Cols, Rows);
    },

    tableMergeCells: function()
    {
        var content = this.getTargetDocContent();
        return content && content.MergeTableCells();
    },

    tableRemoveCol: function()
    {
        var content = this.getTargetDocContent();
        return content && content.RemoveTableColumn();
    },


    tableAddCol: function(bBefore, nCount)
    {
        var content = this.getTargetDocContent();
        return content && content.AddTableColumn(bBefore, nCount);
    },

    tableRemoveRow: function()
    {
        var content = this.getTargetDocContent();
        return content && content.RemoveTableRow();
    },

	tableRemoveCells : function()
	{
		var content = this.getTargetDocContent();
		return content && content.RemoveTableCells();
	},

    tableAddRow: function(bBefore, nCount)
    {
        var content = this.getTargetDocContent();
        return content && content.AddTableRow(bBefore, nCount);
    },

	distributeTableCells : function(isHorizontally)
	{
		var content = this.getTargetDocContent();
		return content && content.DistributeTableCells(isHorizontally);
	},


    documentSearch: function( CurPage, String, search_Common )
    {
        if(this.graphicPages[CurPage])
        {
            this.graphicPages[CurPage].documentSearch(String, search_Common);
            CGraphicPage.prototype.documentSearch.call(this.getHdrFtrObjectsByPageIndex(CurPage), String, search_Common);
        }
    },

    getSelectedElementsInfo: function( Info )
    {

        if(this.selectedObjects.length === 0)
            Info.SetDrawing(-1);

        var content = this.getTargetDocContent();
        if(content)
        {
            Info.SetDrawing(selected_DrawingObjectText);
            content.GetSelectedElementsInfo(Info);
        }
        else
        {
            Info.SetDrawing(selected_DrawingObject);
        }
        return Info;
    },

    getAllObjectsOnPage: function(pageIndex, bHdrFtr)
    {
        var graphic_page;
        if(bHdrFtr)
        {
            graphic_page = this.getHdrFtrObjectsByPageIndex(pageIndex);
        }
        else
        {
            graphic_page = this.graphicPages[pageIndex];
        }
        return graphic_page? graphic_page.behindDocObjects.concat(graphic_page.inlineObjects.concat(graphic_page.beforeTextObjects)) : [];
    },

    selectNextObject: DrawingObjectsController.prototype.selectNextObject,


    getCurrentParagraph: function(bIgnoreSelection, arrSelectedParagraphs, oPr)
    {
        var content = this.getTargetDocContent(oPr && oPr.CheckDocContent, undefined);
        if(content)
        {
            return content.GetCurrentParagraph(bIgnoreSelection, arrSelectedParagraphs, oPr);
        }
        else
        {
            var ParaDrawing = this.getMajorParaDrawing();
            if (ParaDrawing && ParaDrawing.Parent instanceof Paragraph)
                return ParaDrawing.Parent;

            return null;
        }
    },

	getCurrentTablesStack : function(arrTables)
	{
		var oContent = this.getTargetDocContent(false, undefined);
		if (oContent)
			return oContent.GetCurrentTablesStack(arrTables);

		return arrTables ? arrTables : [];
	},

    GetSelectedText: DrawingObjectsController.prototype.GetSelectedText,

    getCurPosXY: function()
    {
        var content = this.getTargetDocContent();
        if(content)
        {
            return content.GetCurPosXY();
        }
        else
        {
            if(this.selectedObjects.length === 1)
            {
                return {X:this.selectedObjects[0].parent.X, Y: this.selectedObjects[0].parent.Y};
            }
            return {X: 0, Y: 0};
        }
    },

    isTextSelectionUse: function()
    {

        var content = this.getTargetDocContent();
        if(content)
        {
            return content.IsTextSelectionUse();
        }
        else
        {
            return false;
        }
    },


    isSelectionUse: function()
    {
        var content = this.getTargetDocContent();
        if(content)
        {
            return content.IsTextSelectionUse();
        }
        else
        {
            return this.selectedObjects.length > 0;
        }
    },

	resetTracking: DrawingObjectsController.prototype.resetTracking,
	getFormatPainterData: DrawingObjectsController.prototype.getFormatPainterData,
	pasteFormatting: DrawingObjectsController.prototype.pasteFormatting,
	checkFormatPainterOnMouseEvent: DrawingObjectsController.prototype.checkFormatPainterOnMouseEvent,
	pasteFormattingWithPoint: DrawingObjectsController.prototype.pasteFormattingWithPoint,

    getHdrFtrObjectsByPageIndex: function(pageIndex)
    {
        if(this.graphicPages[pageIndex])
        {
            return this.graphicPages[pageIndex].hdrFtrPage;
        }
        return null;
    },

    getNearestPos: function(x, y, pageIndex, drawing)
    {
        if(drawing && drawing.GraphicObj)
        {
            if(drawing.GraphicObj.getObjectType() !== AscDFH.historyitem_type_ImageShape && drawing.GraphicObj.getObjectType() !== AscDFH.historyitem_type_OleObject && drawing.GraphicObj.getObjectType() !== AscDFH.historyitem_type_ChartSpace)
                return null;
        }
        this.handleEventMode = HANDLE_EVENT_MODE_CURSOR;
        var cursor_type = this.nullState.onMouseDown(global_mouseEvent, x, y, pageIndex);
        this.handleEventMode = HANDLE_EVENT_MODE_HANDLE;
        var object;
        if(cursor_type )
        {
            object = AscCommon.g_oTableId.Get_ById(cursor_type.objectId);
            if(object)
            {
                if(cursor_type.cursorType === "text")
                {
                    if(object.getNearestPos)
                    {
                        return object.getNearestPos(x, y, pageIndex, drawing);
                    }
                }
                else
                {
                    if((object.getObjectType() === AscDFH.historyitem_type_ImageShape || object.getObjectType() === AscDFH.historyitem_type_OleObject) && object.parent)
                    {
                        var oShape = object.parent.isShapeChild(true);
                        if(oShape)
                        {
                            return oShape.getNearestPos(x, y, pageIndex, drawing);
                        }
                    }
                    else if(object.getObjectType() === AscDFH.historyitem_type_Shape)
                    {
                        if(object.hitInTextRect(x, y))
                        {
                            return object.getNearestPos(x, y, pageIndex, drawing);
                        }
                    }
                }
            }
        }
        return null;
    },

    selectionCheck: function( X, Y, Page_Abs, NearPos )
    {
        var text_object = AscFormat.getTargetTextObject(this);
        if(text_object)
            return text_object.selectionCheck( X, Y, Page_Abs, NearPos );
        return false;
    },

    checkTextObject: function(x, y, pageIndex)
    {
        var text_object = AscFormat.getTargetTextObject(this);
        if(text_object && text_object.hitInTextRect)
        {
            if(text_object.selectStartPage === pageIndex)
            {
                if(text_object.hitInTextRect(x, y))
                {
                    return true;
                }
            }
        }
        return false;
    },

    getParagraphParaPrCopy: function()
    {
        return this.getParagraphParaPr();
    },

    getParagraphTextPrCopy: function()
    {
        return this.getParagraphTextPr();
    },

    getParagraphParaPr: function()
    {
        var ret =  DrawingObjectsController.prototype.getParagraphParaPr.call(this);

        if(ret && ret.Shd && ret.Shd.Unifill)
        {
            ret.Shd.Unifill.check(this.document.theme, this.document.Get_ColorMap());
        }
        return ret ? ret : new CParaPr();
    },

    getColorMap: function()
    {
        return this.document.Get_ColorMap();
    },


	GetStyleFromFormatting: function()
    {
        var oContent = this.getTargetDocContent();
        if(oContent)
        {
            var oStyleFormatting = oContent.GetStyleFromFormatting();
            var oTextPr = oStyleFormatting.TextPr;
            if(oTextPr.TextFill)
            {
                oTextPr.TextFill = undefined;
            }
            if(oTextPr.TextOutline)
            {
                oTextPr.TextOutline = undefined;
            }
            return oStyleFormatting;
        }
        return null;
    },

    getParagraphTextPr: function()
    {
        var ret =  DrawingObjectsController.prototype.getParagraphTextPr.call(this);
        if(ret)
        {
            var ret_;
            if(ret.Unifill && ret.Unifill.canConvertPPTXModsToWord())
            {
                ret_ = ret.Copy();
                ret_.Unifill.convertToWordMods();
            }
            else
            {
                ret_ = ret;
            }
            if(ret_.Unifill)
            {
                ret_.Unifill.check(this.document.theme, this.document.Get_ColorMap());
            }
            return ret_;
        }
        else
        {
            return new CTextPr();
        }
    },

    isSelectedText: function()
    {
        return isRealObject(/*this.selection.textSelection || this.selection.groupSelection && this.selection.groupSelection.selection.textSelection*/this.getTargetDocContent());
    },

    selectAll: DrawingObjectsController.prototype.selectAll,

    startEditTextCurrentShape: DrawingObjectsController.prototype.startEditTextCurrentShape,

    drawSelect: function(pageIndex)
    {
        DrawingObjectsController.prototype.drawSelect.call(this, pageIndex, this.drawingDocument);
    },

    drawBehindDoc: function(pageIndex, graphics)
    {
        if(this.graphicPages[pageIndex])
        {
            graphics.shapePageIndex = pageIndex;
            this.graphicPages[pageIndex].drawBehindDoc(graphics);
            graphics.shapePageIndex = null;
        }
    },

    drawBehindObjectsByContent: function(pageIndex, graphics, content)
    {
        var page;
        if(content.IsHdrFtr())
        {
            //we draw objects from header/footer in drawBehindDocHdrFtr
            return;
        }
        page = this.graphicPages[pageIndex];
        page && page.drawBehindObjectsByContent(graphics, content)
    },

    drawBeforeObjectsByContent: function(pageIndex, graphics, content)
    {
        var page;
        if(content.IsHdrFtr())
        {
            //we draw objects from header/footer in drawBeforeDocHdrFtr
            return;
        }
        page = this.graphicPages[pageIndex];
        page && page.drawBeforeObjectsByContent(graphics, content)
    },


    endTrackShape: function()
    {

    },

    drawBeforeObjects: function(pageIndex, graphics)
    {
        if(this.graphicPages[pageIndex])
        {
            graphics.shapePageIndex = pageIndex;
            this.graphicPages[pageIndex].drawBeforeObjects(graphics);
            graphics.shapePageIndex = null;
        }
    },

    drawBehindDocHdrFtr: function(pageIndex, graphics)
    {

        graphics.shapePageIndex = pageIndex;
        var hdr_footer_objects = this.getHdrFtrObjectsByPageIndex(pageIndex);

        if(hdr_footer_objects != null)
        {
            var behind_doc = hdr_footer_objects.behindDocObjects;
            for(var i = 0; i < behind_doc.length; ++i)
            {
                behind_doc[i].draw(graphics);
            }
        }
        graphics.shapePageIndex = null;
    },


    drawBeforeObjectsHdrFtr: function(pageIndex, graphics)
    {
        graphics.shapePageIndex = pageIndex;
        var hdr_footer_objects = this.getHdrFtrObjectsByPageIndex(pageIndex);
        if(hdr_footer_objects != null)
        {
            var bef_arr = hdr_footer_objects.beforeTextObjects;
            for(var i = 0; i < bef_arr.length; ++i)
            {
                bef_arr[i].draw(graphics);
            }
        }
        graphics.shapePageIndex = null;
    },

    setStartTrackPos: function(x, y, pageIndex)
    {
        this.startTrackPos.x = x;
        this.startTrackPos.y = y;
        this.startTrackPos.pageIndex = pageIndex;
    },

    needUpdateOverlay: function()
    {
        return (this.arrTrackObjects.length > 0) || this.curState.InlinePos;
    },

    changeCurrentState: function(state)
    {
        this.curState = state;
    },

    handleDblClickEmptyShape: function(oShape){
        if(!oShape.getDocContent() && oShape.canEditText()){

            if(false === this.document.Document_Is_SelectionLocked(changestype_Drawing_Props))
            {
                this.document.StartAction(AscDFH.historydescription_Document_GrObjectsBringBackward);
                if(!oShape.bWordShape){
                    oShape.createTextBody();
                }
                else{
                    oShape.createTextBoxContent();
                }
                this.document.Recalculate();
                var oContent = oShape.getDocContent();
                oContent.Set_CurrentElement(0, true);
                oContent.MoveCursorToStartPos(false);
                this.updateSelectionState();
                this.document.FinalizeAction();
            }
            this.clearTrackObjects();
            this.clearPreTrackObjects();
            this.changeCurrentState(new AscFormat.NullState(this));
        }
    },

    canGroup: function(bGetArray)
    {
        var selection_array = this.selectedObjects;
        if(selection_array.length < 2)
            return bGetArray ? [] :false;
        if(!selection_array[0].canGroup())
            return bGetArray ? [] : false;
        var first_page_index = selection_array[0].parent.pageIndex;
        for(var index = 1; index < selection_array.length; ++index)
        {
            if(!selection_array[index].canGroup())
                return  bGetArray ? [] : false;
            if(first_page_index !== selection_array[index].parent.pageIndex)
                return bGetArray ? [] : false;
        }
        if(bGetArray)
        {
            var ret = selection_array.concat([]);
            ret.sort(ComparisonByZIndexSimpleParent);
            return ret;
        }
        return true;
    },

    canUnGroup: DrawingObjectsController.prototype.canUnGroup,
    getBoundsForGroup: DrawingObjectsController.prototype.getBoundsForGroup,




    getArrayForGrouping: function()
    {
        return this.canGroup(true);
    },


    startSelectionFromCurPos: function()
    {
        var content = this.getTargetDocContent();
        if(content)
        {
            content.StartSelectionFromCurPos();
        }
    },


    Check_TrackObjects: function()
    {
        return this.arrTrackObjects.length > 0;
    },

    getGroup: DrawingObjectsController.prototype.getGroup,

	addObjectOnPage : function(pageIndex, object)
	{
		if (!this.graphicPages[pageIndex])
		{
			this.graphicPages[pageIndex] = new CGraphicPage(pageIndex, this);
			for (var z = 0; z < pageIndex; ++z)
			{
				if (!this.graphicPages[z])
					this.graphicPages[z] = new CGraphicPage(z, this);
			}
		}

		if (!object.parent.isHdrFtrChild(false))
		{
			this.graphicPages[pageIndex].addObject(object);
		}
		else
		{
			this.graphicPages[pageIndex].hdrFtrPage.addObject(object);
		}
	},

    cursorGetPos: function()
    {
        var oTargetDocContent = this.getTargetDocContent();
        if(oTargetDocContent){
            var oPos = oTargetDocContent.GetCursorPosXY();
            var oTransform = oTargetDocContent.Get_ParentTextTransform();
            if(oTransform){
                var _x = oTransform.TransformPointX(oPos.X, oPos.Y);
                var _y = oTransform.TransformPointY(oPos.X, oPos.Y);
                return {X: _x, Y: _y};
            }
            return oPos;
        }
        return {X: 0, Y: 0};
    },

	GetSelectionBounds: DrawingObjectsController.prototype.GetSelectionBounds,

    groupSelectedObjects: function()
    {
        var objects_for_grouping = this.canGroup(true);
        if(objects_for_grouping.length < 2)
            return;
		
		let anchorPara = objects_for_grouping[0].parent.Get_ParentParagraph();
		if (!anchorPara)
			return;

		var bTrackRevisions = false;
		if (this.document.IsTrackRevisions())
		{
			bTrackRevisions = this.document.GetLocalTrackRevisions();
			this.document.SetLocalTrackRevisions(false);
		}
        var i;
        var para_drawing = new ParaDrawing(5, 5, null, this.drawingDocument, null, null);
        para_drawing.Set_WrappingType(WRAPPING_TYPE_NONE);
        para_drawing.Set_DrawingType(drawing_Anchor);
        for(i = 0; i < objects_for_grouping.length; ++i)
        {
            if(objects_for_grouping[i].checkExtentsByDocContent && objects_for_grouping[i].checkExtentsByDocContent(true))
            {
                objects_for_grouping[i].updatePosition(objects_for_grouping[i].posX, objects_for_grouping[i].posY)
            }
        }
        var group = this.getGroup(objects_for_grouping);
        var dOffX = group.spPr.xfrm.offX;
        var dOffY = group.spPr.xfrm.offY;
        group.spPr.xfrm.setOffX(0);
        group.spPr.xfrm.setOffY(0);
        group.setParent(para_drawing);
        para_drawing.Set_GraphicObject(group);
        para_drawing.setExtent(group.spPr.xfrm.extX, group.spPr.xfrm.extY);

        var page_index = objects_for_grouping[0].parent.pageIndex;
        let anchorPos = this.document.Get_NearestPos(objects_for_grouping[0].parent.pageIndex, dOffX, dOffY, true, para_drawing);
		
        var nPageIndex = objects_for_grouping[0].parent.pageIndex;
        for(i = 0; i < objects_for_grouping.length; ++i)
        {
			objects_for_grouping[i].parent.bNotPreDelete = true;
            objects_for_grouping[i].parent.Remove_FromDocument(false);
			objects_for_grouping[i].parent.bNotPreDelete = undefined;
            if(objects_for_grouping[i].setParent){
                objects_for_grouping[i].setParent(null);
            }
        }
        para_drawing.Set_Props(new asc_CImgProperty(
            {
                PositionH:
                {
                    RelativeFrom: Asc.c_oAscRelativeFromH.Page,
                    UseAlign : false,
                    Align    : undefined,
                    Value    : dOffX
                },

                PositionV:
                {
                    RelativeFrom: Asc.c_oAscRelativeFromV.Page,
                    UseAlign    : false,
                    Align       : undefined,
                    Value       : dOffY
                }
            }));
		
		if (anchorPos && anchorPos.Paragraph)
		{
			anchorPos.Paragraph.Check_NearestPos(anchorPos);
			para_drawing.Set_XYForAdd(dOffX, dOffY, anchorPos, nPageIndex);
		}

        para_drawing.AddToParagraph(anchorPara);
        para_drawing.Parent = anchorPara;
        this.addGraphicObject(para_drawing);
        this.resetSelection();
        this.selectObject(group, page_index);
        this.document.Recalculate();
        this.document.UpdateInterface();
        this.document.UpdateSelection();
		if (false !== bTrackRevisions)
		{
			this.document.SetLocalTrackRevisions(bTrackRevisions);
		}
		return para_drawing;
    },

    unGroupSelectedObjects: function()
    {
        if(!(this.isViewMode() === false))
            return;

		var bTrackRevisions = false;
		if (this.document.IsTrackRevisions())
		{
			bTrackRevisions = this.document.GetLocalTrackRevisions();
			this.document.SetLocalTrackRevisions(false);
		}
        var ungroup_arr = this.canUnGroup(true);
        if(ungroup_arr.length > 0)
        {
            this.resetSelection();
            var i, j, anchorPos, cur_group, sp_tree, sp, parent_paragraph, page_num;
            var arrCenterPos = [], aPos;
            for(i = 0; i < ungroup_arr.length; ++i)
            {
                cur_group = ungroup_arr[i];
                if(cur_group.getObjectType() === AscDFH.historyitem_type_SmartArt)
                {
                    sp_tree = cur_group.drawing.spTree;
                }
                else
                {
                    sp_tree = cur_group.spTree;
                }
                aPos = [];
                for(j = 0; j < sp_tree.length; ++j)
                {
                    sp = sp_tree[j];
                    xc = sp.transform.TransformPointX(sp.extX/2, sp.extY/2);
                    yc = sp.transform.TransformPointY(sp.extX/2, sp.extY/2);
                    aPos.push({xc: xc, yc: yc});
                }
                arrCenterPos.push(aPos);
            }

            for(i = 0; i < ungroup_arr.length; ++i)
            {
                cur_group = ungroup_arr[i];
                parent_paragraph = cur_group.parent.Get_ParentParagraph();
                page_num = cur_group.selectStartPage;
                cur_group.normalize();
				
				cur_group.parent.bNotPreDelete = true;
                cur_group.parent.Remove_FromDocument(false);
				cur_group.parent.bNotPreDelete = undefined;
                cur_group.setBDeleted(true);
                if(cur_group.getObjectType() === AscDFH.historyitem_type_SmartArt)
                {
                    sp_tree = cur_group.drawing.spTree;
                }
                else
                {
                    sp_tree = cur_group.spTree;
                }
                aPos = arrCenterPos[i];
                var aDrawings = [];
                var drawing;
                this.document.Recalculate(true);
                for(j = 0; j < sp_tree.length; ++j)
                {
                    sp = sp_tree[j];
                    drawing = new ParaDrawing(0, 0, sp_tree[j], this.drawingDocument, null, null);

                    var xc, yc, hc = sp.extX/2, vc = sp.extY/2;
                    if(aPos && aPos[j]){
                        xc = aPos[j].xc;
                        yc = aPos[j].yc;
                    }
                    else {
                        xc = sp.transform.TransformPointX(hc, vc);
                        yc = sp.transform.TransformPointY(hc, vc);
                    }

                    drawing.Set_GraphicObject(sp);
                    sp.setParent(drawing);
                    drawing.Set_DrawingType(drawing_Anchor);
                    drawing.Set_WrappingType(cur_group.parent.wrappingType);
                    drawing.Set_BehindDoc(cur_group.parent.behindDoc);
                    drawing.CheckWH();
                    sp.spPr.xfrm.setRot(AscFormat.normalizeRotate(sp.rot + cur_group.rot));
                    sp.spPr.xfrm.setOffX(0);
                    sp.spPr.xfrm.setOffY(0);
                    sp.spPr.xfrm.setFlipH(cur_group.spPr.xfrm.flipH === true ? !(sp.spPr.xfrm.flipH === true) : sp.spPr.xfrm.flipH === true);
                    sp.spPr.xfrm.setFlipV(cur_group.spPr.xfrm.flipV === true ? !(sp.spPr.xfrm.flipV === true) : sp.spPr.xfrm.flipV === true);
                    sp.setGroup(null);
                    if(sp.spPr.Fill && sp.spPr.Fill.fill && sp.spPr.Fill.fill.type === Asc.c_oAscFill.FILL_TYPE_GRP && cur_group.spPr && cur_group.spPr.Fill)
                    {
                        sp.spPr.setFill(cur_group.spPr.Fill.createDuplicate());
                    }
	
					anchorPos = this.document.Get_NearestPos(page_num, sp.bounds.x + sp.posX, sp.bounds.y + sp.posY, true, drawing);
                    var fPosX = xc - hc;
                    var fPosY = yc - vc;
                    drawing.Set_Props(new asc_CImgProperty(
                    {
                        PositionH:
                        {
                            RelativeFrom: Asc.c_oAscRelativeFromH.Page,
                            UseAlign : false,
                            Align    : undefined,
                            Value    : 0
                        },

                        PositionV:
                        {
                            RelativeFrom: Asc.c_oAscRelativeFromV.Page,
                            UseAlign    : false,
                            Align       : undefined,
                            Value       : 0
                        }
                    }));
					
					if (anchorPos && anchorPos.Paragraph)
					{
						anchorPos.Paragraph.Check_NearestPos(anchorPos);
						drawing.Set_XYForAdd(fPosX, fPosY, anchorPos, page_num);
					}

                    sp.convertFromSmartArt(true);
                    var oSm = sp.hasSmartArt && sp.hasSmartArt(true);
                    if (oSm && oSm.group) {
                        oSm.group.updateCoordinatesAfterInternalResize();
                    }
                    aDrawings.push(drawing);
                }
                for(j = 0; j < aDrawings.length; ++j)
                {
                    drawing = aDrawings[j];
                    drawing.AddToParagraph(parent_paragraph);
                    this.selectObject(drawing.GraphicObj, page_num);
                }
            }
            this.document.Recalculate();
            this.document.UpdateInterface();
            this.document.UpdateSelection();
        }

		if (false !== bTrackRevisions)
		{
			this.document.SetLocalTrackRevisions(bTrackRevisions);
		}
    },

    setTableProps: function(Props)
    {
        var content = this.getTargetDocContent();
        if(content)
        {
            content.SetTableProps(Props);
        }
    },


    selectionIsEmpty: function(bCheckHidden)
    {
        var content = this.getTargetDocContent();
        if(content)
        {
            content.IsSelectionEmpty(bCheckHidden);
        }
        return false;
    },

    moveSelectedObjects: DrawingObjectsController.prototype.moveSelectedObjects,
    moveSelectedObjectsByDir: DrawingObjectsController.prototype.moveSelectedObjectsByDir,

    cursorMoveLeft: DrawingObjectsController.prototype.cursorMoveLeft,

    cursorMoveRight: DrawingObjectsController.prototype.cursorMoveRight,


    cursorMoveUp: DrawingObjectsController.prototype.cursorMoveUp,

    cursorMoveDown: DrawingObjectsController.prototype.cursorMoveDown,

    cursorMoveEndOfLine: DrawingObjectsController.prototype.cursorMoveEndOfLine,
    getMoveDist: DrawingObjectsController.prototype.getMoveDist,


    cursorMoveStartOfLine: DrawingObjectsController.prototype.cursorMoveStartOfLine,

    cursorMoveAt: DrawingObjectsController.prototype.cursorMoveAt,
    getAllConnectors: DrawingObjectsController.prototype.getAllConnectors,
    getAllConnectorsByDrawings: DrawingObjectsController.prototype.getAllConnectorsByDrawings,

    cursorMoveToCell: function(bNext )
    {
        var content = this.getTargetDocContent();
        if(content)
        {
            content.MoveCursorToCell(bNext);
        }
    },

    updateAnchorPos: function()
    {
        //TODO
    },

    resetSelection: DrawingObjectsController.prototype.resetSelection,
    deselectObject: DrawingObjectsController.prototype.deselectObject,

    resetSelection2: function()
    {
        if(this.selectedObjects.length > 0)
        {
            let oTopDrawing = this.selectedObjects[0];
            for(let nDrawing = 1; nDrawing < this.selectedObjects.length; ++nDrawing)
            {
                let oCurDrawing = this.selectedObjects[nDrawing];
                if(oCurDrawing.selectStartPage < oTopDrawing.selectStartPage)
                {
                    oTopDrawing = oCurDrawing;
                }
                else if(oCurDrawing.selectStartPage === oTopDrawing.selectStartPage)
                {
                    if(oCurDrawing.parent.Get_ParentParagraph().Y < oTopDrawing.parent.Get_ParentParagraph().Y)
                        oTopDrawing = oCurDrawing;
                }
            }
            this.resetSelection();
            oTopDrawing.parent.GoToText();
        }
        else
        {
            if(this.lastSelectedObject)
            {
                let oParaDrawing = this.lastSelectedObject.parent;
                if(oParaDrawing && oParaDrawing.IsUseInDocument())
                {
                    oParaDrawing.GoToText();
                }
            }
        }
    },

    goToSignature: function(sGuid)
    {
        if(!this.document)
        {
            return;
        }
        var oDrawingDocument = this.document.GetDrawingDocument();
        if(!oDrawingDocument)
        {
            return;
        }
        var oWordControl = oDrawingDocument.m_oWordControl;
        if(!oWordControl)
        {
            return;
        }
        var aSignatureShapes = this.getAllSignatures2([], this.getDrawingArray());
        var oShape;
        for(var i = 0; i < aSignatureShapes.length; ++i)
        {
            oShape = aSignatureShapes[i];
            if(oShape && !oShape.group && oShape.signatureLine && oShape.signatureLine.id === sGuid && oShape.parent)
            {
                oWordControl.ScrollToPosition(oShape.x, oShape.y, oShape.parent.PageNum, oShape.extY);
                oShape.Set_CurrentElement(false, oShape.parent.PageNum);
                this.selection.textSelection = null;
                this.document.Document_UpdateInterfaceState();
                this.document.Document_UpdateRulersState();
                this.document.Document_UpdateSelectionState();
                return;
            }
        }
    },


    recalculateCurPos: function(bUpdateX, bUpdateY)
    {
        var oTargetDocContent = this.getTargetDocContent(undefined, true);
        if (oTargetDocContent)
            return oTargetDocContent.RecalculateCurPos(bUpdateX, bUpdateY);

        if (!window["NATIVE_EDITOR_ENJINE"]) {

            var oParaDrawing = this.getMajorParaDrawing();
            if (oParaDrawing)
            {
            	var oLogicDocument = editor.WordControl.m_oLogicDocument;

            	if (oLogicDocument && !oLogicDocument.Selection.Start)
				{
					// Обновляем позицию курсора, чтобы проскроллиться к заданной позиции
					var oDrawingDocument = oLogicDocument.GetDrawingDocument();
					oDrawingDocument.m_oWordControl.ScrollToPosition(oParaDrawing.GraphicObj.transform.tx, oParaDrawing.GraphicObj.transform.ty, oParaDrawing.PageNum, oParaDrawing.GraphicObj.extY);
					
					return {
						X         : oParaDrawing.GraphicObj.x,
						Y         : oParaDrawing.GraphicObj.y,
						Height    : 0,
						PageNum   : oParaDrawing.PageNum,
						Internal  : {
							Line  : 0,
							Page  : 0,
							Range : 0
						},
						Transform : null
					};
				}
            }
        }

        return {
            X         : 0,
            Y         : 0,
            Height    : 0,
            PageNum   : 0,
            Internal  : {Line : 0, Page : 0, Range : 0},
            Transform : null
        };
    },
		removeFromGroup: function(oMainGroup, arrShapes) {
			if(oMainGroup.getObjectType() === AscDFH.historyitem_type_GroupShape)
			{
				var group_map = {}, group_arr = [], i, cur_group, sp, xc, yc, hc, vc, rel_xc, rel_yc, j;
				for(i = 0; i < arrShapes.length; ++i)
				{
					arrShapes[i].group.removeFromSpTree(arrShapes[i].Get_Id());
					group_map[arrShapes[i].group.Get_Id()+""] = arrShapes[i].group;
				}
				group_map[oMainGroup.Get_Id()] = oMainGroup;
				for(var key in group_map)
				{
					if(group_map.hasOwnProperty(key))
						group_arr.push(group_map[key]);
				}
				group_arr.sort(AscFormat.CompareGroups);
				for(i = 0; i < group_arr.length; ++i)
				{
					cur_group = group_arr[i];
					if(isRealObject(cur_group.group))
					{
						if(cur_group.spTree.length === 0)
						{
							cur_group.group.removeFromSpTree(cur_group.Get_Id());
						}
						else if(cur_group.spTree.length === 1)
						{
							sp = cur_group.spTree[0];
							hc = sp.spPr.xfrm.extX/2;
							vc = sp.spPr.xfrm.extY/2;
							xc = sp.transform.TransformPointX(hc, vc);
							yc = sp.transform.TransformPointY(hc, vc);
							rel_xc = cur_group.group.invertTransform.TransformPointX(xc, yc);
							rel_yc = cur_group.group.invertTransform.TransformPointY(xc, yc);
							sp.spPr.xfrm.setOffX(rel_xc - hc);
							sp.spPr.xfrm.setOffY(rel_yc - vc);
							sp.spPr.xfrm.setRot(AscFormat.normalizeRotate(cur_group.rot + sp.rot));
							sp.spPr.xfrm.setFlipH(cur_group.spPr.xfrm.flipH === true ? !(sp.spPr.xfrm.flipH === true) : sp.spPr.xfrm.flipH === true);
							sp.spPr.xfrm.setFlipV(cur_group.spPr.xfrm.flipV === true ? !(sp.spPr.xfrm.flipV === true) : sp.spPr.xfrm.flipV === true);
							sp.setGroup(cur_group.group);
							for(j = 0; j < cur_group.group.spTree.length; ++j)
							{
								if(cur_group.group.spTree[j] === cur_group)
								{
									cur_group.group.addToSpTree(j, sp);
									cur_group.group.removeFromSpTree(cur_group.Get_Id());
								}
							}
						}
					}
					else
					{
						var para_drawing = cur_group.parent;
						if(cur_group.spTree.length === 0)
						{
							para_drawing.GoToText();
							para_drawing.PreDelete();
							para_drawing.Remove_FromDocument(false);
							if (this.selection.groupSelection === cur_group) {
								this.resetSelection();
						}
							return true;
						}
						else if(cur_group.spTree.length === 1)
						{
							sp = cur_group.spTree[0];
							sp.spPr.xfrm.setOffX(0);
							sp.spPr.xfrm.setOffY(0);
							sp.spPr.xfrm.setRot(AscFormat.normalizeRotate(cur_group.rot + sp.rot));
							sp.spPr.xfrm.setFlipH(cur_group.spPr.xfrm.flipH === true ? !(sp.spPr.xfrm.flipH === true) : sp.spPr.xfrm.flipH === true);
							sp.spPr.xfrm.setFlipV(cur_group.spPr.xfrm.flipV === true ? !(sp.spPr.xfrm.flipV === true) : sp.spPr.xfrm.flipV === true);
							sp.setGroup(null);
							para_drawing.Set_GraphicObject(sp);
							sp.setParent(para_drawing);
							if (cur_group.selected || sp.selected) {
								this.resetSelection();
								this.selectObject(sp, cur_group.selectStartPage);
							}
							new_x = sp.transform.tx;
							new_y = sp.transform.ty;
							para_drawing.CheckWH();
							if(!para_drawing.Is_Inline())
							{
								para_drawing.Set_XY(new_x, new_y, para_drawing.Get_ParentParagraph(), para_drawing.GraphicObj.selectStartPage, true);
							}
							return true;
						}
						else
						{
							if (this.selection.groupSelection === cur_group) {
								this.resetInternalSelection();
							}
							var new_x, new_y;
							// var pos = cur_group.getBoundsPos();
							var oPos = cur_group.updateCoordinatesAfterInternalResize();

							var g_pos_x = 0, g_pos_y = 0;
							if(oPos)
							{
								if(AscFormat.isRealNumber(oPos.posX))
								{
									g_pos_x = oPos.posX;
								}
								if(AscFormat.isRealNumber(oPos.posY))
								{
									g_pos_y = oPos.posY;
								}
							}
							new_x = cur_group.x + g_pos_x;
							new_y = cur_group.y + g_pos_y;

							cur_group.spPr.xfrm.setOffX(0);
							cur_group.spPr.xfrm.setOffY(0);
							para_drawing.CheckWH();
							para_drawing.Set_XY(new_x, new_y, cur_group.parent.Get_ParentParagraph(), cur_group.selectStartPage, false);//X, Y, Paragraph, PageNum, bResetAlign
							return true;
						}
					}
				}
			}
		},
    remove: function(Count, bOnlyText, bRemoveOnlySelection, bOnTextAdd, isWord)
    {
        var content = this.getTargetDocContent(true);
        if(content)
        {
            content.Remove(Count, bOnlyText, bRemoveOnlySelection, bOnTextAdd, isWord);
            var oTargetTextObject = AscFormat.getTargetTextObject(this);
            oTargetTextObject && oTargetTextObject.checkExtentsByDocContent && oTargetTextObject.checkExtentsByDocContent();
            this.document.Recalculate();
        }
        else if(this.selectedObjects.length > 0)
        {
            if(this.selection.groupSelection)
            {
                if(this.selection.groupSelection.selection.chartSelection)
                {
                    this.selection.groupSelection.selection.chartSelection.remove();
                    this.document.Recalculate();
                }
                else if (this.removeFromGroup(this.selection.groupSelection, this.selection.groupSelection.selectedObjects))
                {
	                this.document.Recalculate();
                }
            }
            else if(this.selection.chartSelection)
            {
                this.selection.chartSelection.remove();
                this.document.Recalculate();

            }
            else
            {
                let aSelectedObjects = [].concat(this.selectedObjects);
                let oFirstSelected = aSelectedObjects[0];
                let oFirstParaDrawing = oFirstSelected.parent;
                this.resetSelection();
                if(oFirstParaDrawing) 
                {
                    oFirstParaDrawing.GoToText();
                }
                for(let nDrawing = 0; nDrawing < aSelectedObjects.length; ++nDrawing)
                {
                    let oSp = aSelectedObjects[nDrawing];
                    let oParaDrawing = oSp.parent;
                    if(oParaDrawing) 
                    {
                        oParaDrawing.PreDelete();
                        oParaDrawing.Remove_FromDocument(false);
                    }
                }
                this.document.Recalculate();
            }
        }
    },

    addGraphicObject: function(paraDrawing)
    {
        this.drawingObjects.push(paraDrawing);
    },

    getZIndex: function()
    {
        this.maximalGraphicObjectZIndex+=1024;
        return this.maximalGraphicObjectZIndex;
    },

    IsInDrawingObject: function(X, Y, nPageIndex, oContent){
        var _X, _Y, oTransform, oInvertTransform;
        if(oContent){
            oTransform = oContent.Get_ParentTextTransform();
            if(oTransform){
                oInvertTransform = AscCommon.global_MatrixTransformer.Invert(oTransform);
                _X = oInvertTransform.TransformPointX(X, Y);
                _Y = oInvertTransform.TransformPointY(X, Y);
            }
            else{
                _X = X;
                _Y = Y;
            }
        }
        else{
            _X = X;
            _Y = Y;
        }
        return this.isPointInDrawingObjects(_X, _Y, nPageIndex);
    },

    isPointInDrawingObjects: function(x, y, pageIndex, bSelected, bNoText)
    {
        var ret;
        this.handleEventMode = HANDLE_EVENT_MODE_CURSOR;
        ret = this.curState.onMouseDown(global_mouseEvent, x, y, pageIndex);
        this.handleEventMode = HANDLE_EVENT_MODE_HANDLE;
        if(isRealObject(ret))
        {
            if(bNoText === true)
            {
                if(ret.cursorType === "text")
                {
                    return -1;
                }
            }
            var object = AscCommon.g_oTableId.Get_ById(ret.objectId);
            if(isRealObject(object) && (!(bSelected === true) ||  bSelected && object.selected) )
            {
                if(object.group)
                    object = object.getMainGroup();

                if(isRealObject(object) && isRealObject(object.parent))
                {
                    if(ret.bMarker)
                    {
                        return DRAWING_ARRAY_TYPE_BEFORE;
                    }
                    else
                    {
                        if(object.parent.getDrawingArrayType)
                        {
                            return object.parent.getDrawingArrayType();
                        }
                        return DRAWING_ARRAY_TYPE_BEFORE;
                    }
                }
            }
            else
            {
                if(!(bSelected === true))
                {
                    return DRAWING_ARRAY_TYPE_BEFORE;
                }
                return -1;
            }
        }
        return -1;
    },

    isPointInDrawingObjects2: function(x, y, pageIndex, bSelected)
    {
        return this.isPointInDrawingObjects(x, y, pageIndex, bSelected, true) > -1;
    },

    isPointInDrawingObjects3: function(x, y, pageIndex, bSelected, bText)
    {
        if(bText){
            var ret;
            this.handleEventMode = HANDLE_EVENT_MODE_CURSOR;
            ret = this.curState.onMouseDown(global_mouseEvent, x, y, pageIndex);
            this.handleEventMode = HANDLE_EVENT_MODE_HANDLE;
            if(isRealObject(ret)){
                if(ret.cursorType === "text")
                {
                    return true;
                }
            }
            return false;
        }
        var oOldState = this.curState;
        this.changeCurrentState(new AscFormat.NullState(this));
        var bRet = this.isPointInDrawingObjects(x, y, pageIndex, bSelected, true) > -1;
        this.changeCurrentState(oOldState);
        return bRet;
    },


    pointInObjInDocContent: function( docContent, X, Y, pageIndex )
    {
        var ret;
        this.handleEventMode = HANDLE_EVENT_MODE_CURSOR;
        ret = this.curState.onMouseDown(global_mouseEvent, X, Y, pageIndex);
        this.handleEventMode = HANDLE_EVENT_MODE_HANDLE;
        if(ret)
        {
            var object = AscCommon.g_oTableId.Get_ById(ret.objectId);
            if(object)
            {
                var parent_drawing;
                if(!object.group && object.parent)
                {
                    parent_drawing = object;
                }
                else if(object.group)
                {
                    parent_drawing = object.group;
                    while(parent_drawing.group)
                        parent_drawing = parent_drawing.group;
                }
                if(parent_drawing &&  parent_drawing.parent)
                    return docContent === parent_drawing.parent.isInTopDocument(true);
            }
        }
        return false;
    },

    pointInSelectedObject: function(x, y, pageIndex)
    {
        var ret;
        this.handleEventMode = HANDLE_EVENT_MODE_CURSOR;
        ret = this.curState.onMouseDown(global_mouseEvent, x, y, pageIndex);
        this.handleEventMode = HANDLE_EVENT_MODE_HANDLE;
        if(ret)
        {
            var object = AscCommon.g_oTableId.Get_ById(ret.objectId);
            if(object && object.selected /*&& object.selectStartPage === pageIndex*/)
                return true;
        }
        return false;
    },

	getParagraphByXY: DrawingObjectsController.prototype.getParagraphByXY,

    checkTargetSelection: function()
    {
        return false;
    },

    getSelectedDrawingObjectsCount: function()
    {
        if(this.selection.groupSelection)
        {
            return this.selection.groupSelection.selectedObjects.length;
        }
        return this.selectedObjects.length;
    },

    putShapesAlign: function(type, alignType)
    {
        var Bounds;
        if(this.selectedObjects.length < 1)
        {
            return;
        }
        if(!this.selection.groupSelection)
        {
            if(alignType === Asc.c_oAscObjectsAlignType.Page || alignType === Asc.c_oAscObjectsAlignType.Margin || this.selectedObjects.length < 2)
            {
                var oApi = this.getEditorApi();
                if(!oApi)
                {
                    return;
                }
                var oImageProperties = new Asc.asc_CImgProperty();
                var oPosition;
                if(alignType === Asc.c_oAscObjectsAlignType.Page)
                {
                    if(type === c_oAscAlignShapeType.ALIGN_LEFT
                        || type === c_oAscAlignShapeType.ALIGN_RIGHT
                        || type === c_oAscAlignShapeType.ALIGN_CENTER)
                    {
                        oPosition = new Asc.CImagePositionH();
                        oImageProperties.asc_putPositionH(oPosition);
                        oPosition.put_UseAlign(true);
                        oPosition.put_RelativeFrom(Asc.c_oAscRelativeFromH.Page);
                    }
                    else
                    {
                        oPosition = new Asc.CImagePositionV();
                        oImageProperties.asc_putPositionV(oPosition);
                        oPosition.put_UseAlign(true);
                        oPosition.put_RelativeFrom(Asc.c_oAscRelativeFromV.Page);
                    }
                }
                else
                {
                    if(type === c_oAscAlignShapeType.ALIGN_LEFT
                        || type === c_oAscAlignShapeType.ALIGN_RIGHT
                        || type === c_oAscAlignShapeType.ALIGN_CENTER)
                    {
                        oPosition = new Asc.CImagePositionH();
                        oImageProperties.asc_putPositionH(oPosition);
                        oPosition.put_UseAlign(true);
                        oPosition.put_RelativeFrom(Asc.c_oAscRelativeFromH.Margin);
                    }
                    else
                    {
                        oPosition = new Asc.CImagePositionV();
                        oImageProperties.asc_putPositionV(oPosition);
                        oPosition.put_UseAlign(true);
                        oPosition.put_RelativeFrom(Asc.c_oAscRelativeFromV.Margin);
                    }
                }
                switch (type)
                {
                    case c_oAscAlignShapeType.ALIGN_LEFT:
                    {
                        oPosition.put_Align(c_oAscAlignH.Left);
                        break;
                    }
                    case c_oAscAlignShapeType.ALIGN_RIGHT:
                    {
                        oPosition.put_Align(c_oAscAlignH.Right);
                        break;
                    }
                    case c_oAscAlignShapeType.ALIGN_TOP:
                    {
                        oPosition.put_Align(c_oAscAlignV.Top);
                        break;
                    }
                    case c_oAscAlignShapeType.ALIGN_BOTTOM:
                    {
                        oPosition.put_Align(c_oAscAlignV.Bottom);
                        break;
                    }
                    case c_oAscAlignShapeType.ALIGN_CENTER:
                    {
                        oPosition.put_Align(c_oAscAlignH.Center);
                        break;
                    }
                    case c_oAscAlignShapeType.ALIGN_MIDDLE:
                    {
                        oPosition.put_Align(c_oAscAlignV.Center);
                        break;
                    }
                    default:
                        break;
                }
                oApi.ImgApply(oImageProperties);
            }
            else
            {
                Bounds = AscFormat.getAbsoluteRectBoundsArr(this.selectedObjects);
                switch (type)
                {
                    case c_oAscAlignShapeType.ALIGN_LEFT:
                    {
                        this.alignLeft(Bounds.minX, Bounds.arrBounds);
                        break;
                    }
                    case c_oAscAlignShapeType.ALIGN_RIGHT:
                    {
                        this.alignRight(Bounds.maxX, Bounds.arrBounds);
                        break;
                    }
                    case c_oAscAlignShapeType.ALIGN_TOP:
                    {
                        this.alignTop(Bounds.minY, Bounds.arrBounds);
                        break;
                    }
                    case c_oAscAlignShapeType.ALIGN_BOTTOM:
                    {
                        this.alignBottom(Bounds.maxY, Bounds.arrBounds);
                        break;
                    }
                    case c_oAscAlignShapeType.ALIGN_CENTER:
                    {
                        this.alignCenter((Bounds.maxX + Bounds.minX)/2, Bounds.arrBounds);
                        break;
                    }
                    case c_oAscAlignShapeType.ALIGN_MIDDLE:
                    {
                        this.alignMiddle((Bounds.maxY + Bounds.minY)/2, Bounds.arrBounds);
                        break;
                    }
                    default:
                        break;
                }
            }
        }
        else
        {
            var selectedObjects = this.selection.groupSelection.selectedObjects;
            if(selectedObjects.length < 1)
            {
                return;
            }
            Bounds = AscFormat.getAbsoluteRectBoundsArr(selectedObjects);
            if(alignType === Asc.c_oAscObjectsAlignType.Page || alignType === Asc.c_oAscObjectsAlignType.Margin || selectedObjects.length < 2)
            {
                var oFirstDrawing = selectedObjects[0];
                while(oFirstDrawing.group)
                {
                    oFirstDrawing = oFirstDrawing.group;
                }
                if(!oFirstDrawing.parent)
                {
                    return;
                }
                var oParentParagraph = oFirstDrawing.parent.Get_ParentParagraph();
                var oSectPr = oParentParagraph.Get_SectPr();
                if(!oSectPr)
                {
                    return;
                }

                if(alignType === Asc.c_oAscObjectsAlignType.Page)
                {
                    switch (type)
                    {
                        case c_oAscAlignShapeType.ALIGN_LEFT:
                        {
                            this.alignLeft(0, Bounds.arrBounds);
                            break;
                        }
                        case c_oAscAlignShapeType.ALIGN_RIGHT:
                        {
                            this.alignRight(oSectPr.GetPageWidth(), Bounds.arrBounds);
                            break;
                        }
                        case c_oAscAlignShapeType.ALIGN_TOP:
                        {
                            this.alignTop(0, Bounds.arrBounds);
                            break;
                        }
                        case c_oAscAlignShapeType.ALIGN_BOTTOM:
                        {
                            this.alignBottom(oSectPr.GetPageHeight(), Bounds.arrBounds);
                            break;
                        }
                        case c_oAscAlignShapeType.ALIGN_CENTER:
                        {
                            this.alignCenter(oSectPr.GetPageWidth()/2, Bounds.arrBounds);
                            break;
                        }
                        case c_oAscAlignShapeType.ALIGN_MIDDLE:
                        {
                            this.alignMiddle(oSectPr.GetPageHeight()/2, Bounds.arrBounds);
                            break;
                        }
                        default:
                            break;
                    }
                }
                else
                {
					var oFrame = oSectPr.GetContentFrame(this.selection.groupSelection.parent.PageNum);
					switch (type)
                    {
                        case c_oAscAlignShapeType.ALIGN_LEFT:
                        {
                            this.alignLeft(oFrame.Left, Bounds.arrBounds);
                            break;
                        }
                        case c_oAscAlignShapeType.ALIGN_RIGHT:
                        {
                            this.alignRight(oFrame.Right, Bounds.arrBounds);
                            break;
                        }
                        case c_oAscAlignShapeType.ALIGN_TOP:
                        {
                            this.alignTop(oFrame.Top, Bounds.arrBounds);
                            break;
                        }
                        case c_oAscAlignShapeType.ALIGN_BOTTOM:
                        {
                            this.alignBottom(oFrame.Bottom, Bounds.arrBounds);
                            break;
                        }
                        case c_oAscAlignShapeType.ALIGN_CENTER:
                        {
                            this.alignCenter((oFrame.Left + oFrame.Right) / 2, Bounds.arrBounds);
                            break;
                        }
                        case c_oAscAlignShapeType.ALIGN_MIDDLE:
                        {
                            this.alignMiddle((oFrame.Top + oFrame.Bottom) / 2, Bounds.arrBounds);
                            break;
                        }
                        default:
                            break;
                    }
                }
            }
            else
            {
                switch (type)
                {
                    case c_oAscAlignShapeType.ALIGN_LEFT:
                    {
                        this.alignLeft(Bounds.minX, Bounds.arrBounds);
                        break;
                    }
                    case c_oAscAlignShapeType.ALIGN_RIGHT:
                    {
                        this.alignRight(Bounds.maxX, Bounds.arrBounds);
                        break;
                    }
                    case c_oAscAlignShapeType.ALIGN_TOP:
                    {
                        this.alignTop(Bounds.minY, Bounds.arrBounds);
                        break;
                    }
                    case c_oAscAlignShapeType.ALIGN_BOTTOM:
                    {
                        this.alignBottom(Bounds.maxY, Bounds.arrBounds);
                        break;
                    }
                    case c_oAscAlignShapeType.ALIGN_CENTER:
                    {
                        this.alignCenter((Bounds.maxX + Bounds.minX)/2, Bounds.arrBounds);
                        break;
                    }
                    case c_oAscAlignShapeType.ALIGN_MIDDLE:
                    {
                        this.alignMiddle((Bounds.maxY + Bounds.minY)/2, Bounds.arrBounds);
                        break;
                    }
                    default:
                        break;
                }
            }
        }
    },

    alignLeft: function(Pos, arrBounds)
    {
        var selected_objects = this.selection.groupSelection ? this.selection.groupSelection.selectedObjects : this.selectedObjects, i, boundsObject, leftPos;
        if(selected_objects.length > 0)
        {
            this.checkSelectedObjectsForMove();
            this.swapTrackObjects();
            var move_state;
            if(!this.selection.groupSelection)
                move_state = new AscFormat.MoveState(this, this.selectedObjects[0], 0, 0);
            else
                move_state = new AscFormat.MoveInGroupState(this, this.selection.groupSelection.selectedObjects[0], this.selection.groupSelection, 0, 0);

            for(i = 0; i < this.arrTrackObjects.length; ++i)
                this.arrTrackObjects[i].track(Pos - arrBounds[i].minX, 0, this.arrTrackObjects[i].originalObject.selectStartPage);
            move_state.bSamePos = false;
            move_state.onMouseUp({}, 0, 0, 0);
        }
    },

    alignRight: function(Pos, arrBounds)
    {
        var selected_objects = this.selection.groupSelection ? this.selection.groupSelection.selectedObjects : this.selectedObjects, i, boundsObject, leftPos;
        if(selected_objects.length > 0)
        {
            this.checkSelectedObjectsForMove();
            this.swapTrackObjects();
            var move_state;
            if(!this.selection.groupSelection)
                move_state = new AscFormat.MoveState(this, this.selectedObjects[0], 0, 0);
            else
                move_state = new AscFormat.MoveInGroupState(this, this.selection.groupSelection.selectedObjects[0], this.selection.groupSelection, 0, 0);

            for(i = 0; i < this.arrTrackObjects.length; ++i)
                this.arrTrackObjects[i].track(Pos - arrBounds[i].maxX, 0, this.arrTrackObjects[i].originalObject.selectStartPage);
            move_state.bSamePos = false;
            move_state.onMouseUp({}, 0, 0, 0);
        }
    },

    alignTop: function(Pos, arrBounds)
    {
        var selected_objects = this.selection.groupSelection ? this.selection.groupSelection.selectedObjects : this.selectedObjects, i, boundsObject, leftPos;
        if(selected_objects.length > 0)
        {
            this.checkSelectedObjectsForMove();
            this.swapTrackObjects();
            var move_state;
            if(!this.selection.groupSelection)
                move_state = new AscFormat.MoveState(this, this.selectedObjects[0], 0, 0);
            else
                move_state = new AscFormat.MoveInGroupState(this, this.selection.groupSelection.selectedObjects[0], this.selection.groupSelection, 0, 0);

            for(i = 0; i < this.arrTrackObjects.length; ++i)
                this.arrTrackObjects[i].track(0, Pos - arrBounds[i].minY, this.arrTrackObjects[i].originalObject.selectStartPage);
            move_state.bSamePos = false;
            move_state.onMouseUp({}, 0, 0, 0);
        }
    },

    alignBottom: function(Pos, arrBounds)
    {
        var selected_objects = this.selection.groupSelection ? this.selection.groupSelection.selectedObjects : this.selectedObjects, i, boundsObject, leftPos;
        if(selected_objects.length > 0)
        {
            this.checkSelectedObjectsForMove();
            this.swapTrackObjects();
            var move_state;
            if(!this.selection.groupSelection)
                move_state = new AscFormat.MoveState(this, this.selectedObjects[0], 0, 0);
            else
                move_state = new AscFormat.MoveInGroupState(this, this.selection.groupSelection.selectedObjects[0], this.selection.groupSelection, 0, 0);

            for(i = 0; i < this.arrTrackObjects.length; ++i)
                this.arrTrackObjects[i].track(0, Pos - arrBounds[i].maxY, this.arrTrackObjects[i].originalObject.selectStartPage);
            move_state.bSamePos = false;
            move_state.onMouseUp({}, 0, 0, 0);
        }
    },

    alignCenter : function(Pos, arrBounds)
    {
        var selected_objects = this.selection.groupSelection ? this.selection.groupSelection.selectedObjects : this.selectedObjects, i;
        if(selected_objects.length > 0)
        {
            this.checkSelectedObjectsForMove();
            this.swapTrackObjects();
            var move_state;
            if(!this.selection.groupSelection)
                move_state = new AscFormat.MoveState(this, this.selectedObjects[0], 0, 0);
            else
                move_state = new AscFormat.MoveInGroupState(this, this.selection.groupSelection.selectedObjects[0], this.selection.groupSelection, 0, 0);

            for(i = 0; i < this.arrTrackObjects.length; ++i)
                this.arrTrackObjects[i].track(Pos - (arrBounds[i].maxX - arrBounds[i].minX)/2 - arrBounds[i].minX, 0, this.arrTrackObjects[i].originalObject.selectStartPage);
            move_state.bSamePos = false;
            move_state.onMouseUp({}, 0, 0, 0);
        }
    },

    alignMiddle : function(Pos, arrBounds)
    {
        var selected_objects = this.selection.groupSelection ? this.selection.groupSelection.selectedObjects : this.selectedObjects, i;
        if(selected_objects.length > 0)
        {
            this.checkSelectedObjectsForMove();
            this.swapTrackObjects();
            var move_state;
            if(!this.selection.groupSelection)
                move_state = new AscFormat.MoveState(this, this.selectedObjects[0], 0, 0);
            else
                move_state = new AscFormat.MoveInGroupState(this, this.selection.groupSelection.selectedObjects[0], this.selection.groupSelection, 0, 0);

            for(i = 0; i < this.arrTrackObjects.length; ++i)
                this.arrTrackObjects[i].track(0, Pos - (arrBounds[i].maxY - arrBounds[i].minY)/2 - arrBounds[i].minY, this.arrTrackObjects[i].originalObject.selectStartPage);
            move_state.bSamePos = false;
            move_state.onMouseUp({}, 0, 0, 0);
        }
    },


    distributeHor : function(alignType)
    {
        var selected_objects = this.selection.groupSelection ? this.selection.groupSelection.selectedObjects : this.selectedObjects, i, boundsObject, arrBounds, pos1, pos2, gap, sortObjects, lastPos;
        if(selected_objects.length > 0)
        {
            boundsObject = AscFormat.getAbsoluteRectBoundsArr(selected_objects);
            arrBounds = boundsObject.arrBounds;
            this.checkSelectedObjectsForMove();
            this.swapTrackObjects();
            sortObjects = [];
            for(i = 0; i < selected_objects.length; ++i)
            {
                sortObjects.push({trackObject: this.arrTrackObjects[i], boundsObject: arrBounds[i]});
            }
            sortObjects.sort(function(obj1, obj2){return (obj1.boundsObject.maxX + obj1.boundsObject.minX)/2 - (obj2.boundsObject.maxX + obj2.boundsObject.minX)/2});

            if(alignType === Asc.c_oAscObjectsAlignType.Selected && selected_objects.length > 2)
            {
                pos1 = sortObjects[0].boundsObject.minX;
                pos2 = sortObjects[sortObjects.length - 1].boundsObject.maxX;
            }
            else
            {
                var oFirstDrawing = selected_objects[0];
                while(oFirstDrawing.group)
                {
                    oFirstDrawing = oFirstDrawing.group;
                }
                if(!oFirstDrawing.parent)
                {
                    return;
                }
                var oParentParagraph = oFirstDrawing.parent.Get_ParentParagraph();
                var oSectPr = oParentParagraph.Get_SectPr();
                if(!oSectPr)
                {
                    return;
                }

                if(alignType === Asc.c_oAscObjectsAlignType.Page)
                {
                    pos1 = 0;
                    pos2 = oSectPr.GetPageWidth();
                }
                else
                {
					var oFrame = oSectPr.GetContentFrame(sortObjects[0].trackObject.originalObject.selectStartPage);

					pos1 = oFrame.Left;
                    pos2 = oFrame.Right;
                }
            }
            var summ_width = boundsObject.summWidth;
            gap = (pos2 - pos1 - summ_width)/(sortObjects.length - 1);
            var move_state;
            if(!this.selection.groupSelection)
                move_state = new AscFormat.MoveState(this, this.selectedObjects[0], 0, 0);
            else
                move_state = new AscFormat.MoveInGroupState(this, this.selection.groupSelection.selectedObjects[0], this.selection.groupSelection, 0, 0);

            lastPos = pos1;
            for(i = 0; i < sortObjects.length; ++i)
            {
                sortObjects[i].trackObject.track(lastPos -  sortObjects[i].trackObject.originalObject.x, 0, sortObjects[i].trackObject.originalObject.selectStartPage);
                lastPos += (gap + (sortObjects[i].boundsObject.maxX - sortObjects[i].boundsObject.minX));
            }
            move_state.bSamePos = false;
            move_state.onMouseUp({}, 0, 0, 0);
        }
    },
    distributeVer : function(alignType)
    {
        var selected_objects = this.selection.groupSelection ? this.selection.groupSelection.selectedObjects : this.selectedObjects, i, boundsObject, arrBounds, pos1, pos2, gap, sortObjects, lastPos;
        if(selected_objects.length > 0)
        {
            boundsObject = AscFormat.getAbsoluteRectBoundsArr(selected_objects);
            arrBounds = boundsObject.arrBounds;
            this.checkSelectedObjectsForMove();
            this.swapTrackObjects();
            sortObjects = [];
            for(i = 0; i < selected_objects.length; ++i)
            {
                sortObjects.push({trackObject: this.arrTrackObjects[i], boundsObject: arrBounds[i]});
            }
            sortObjects.sort(function(obj1, obj2){return (obj1.boundsObject.maxY + obj1.boundsObject.minY)/2 - (obj2.boundsObject.maxY + obj2.boundsObject.minY)/2});

            if(alignType === Asc.c_oAscObjectsAlignType.Selected && selected_objects.length > 2)
            {
                pos1 = sortObjects[0].boundsObject.minY;
                pos2 = sortObjects[sortObjects.length - 1].boundsObject.maxY;
            }
            else
            {
                var oFirstDrawing = selected_objects[0];
                while(oFirstDrawing.group)
                {
                    oFirstDrawing = oFirstDrawing.group;
                }
                if(!oFirstDrawing.parent)
                {
                    return;
                }
                var oParentParagraph = oFirstDrawing.parent.Get_ParentParagraph();
                var oSectPr = oParentParagraph.Get_SectPr();
                if(!oSectPr)
                {
                    return;
                }

                if(alignType === Asc.c_oAscObjectsAlignType.Page)
                {
                    pos1 = 0;
                    pos2 = oSectPr.GetPageHeight();
                }
                else
                {
					var oFrame = oSectPr.GetContentFrame(sortObjects[0].trackObject.originalObject.selectStartPage);

                    pos1 = oFrame.Top;
                    pos2 = oFrame.Bottom;
                }
            }
            var summ_height = boundsObject.summHeight;
            gap = (pos2 - pos1 - summ_height)/(sortObjects.length - 1);
            var move_state;
            if(!this.selection.groupSelection)
                move_state = new AscFormat.MoveState(this, this.selectedObjects[0], 0, 0);
            else
                move_state = new AscFormat.MoveInGroupState(this, this.selection.groupSelection.selectedObjects[0], this.selection.groupSelection, 0, 0);

            lastPos = pos1;
            for(i = 0; i < sortObjects.length; ++i)
            {
                sortObjects[i].trackObject.track(0, lastPos -  sortObjects[i].trackObject.originalObject.y, sortObjects[i].trackObject.originalObject.selectStartPage);
                lastPos += (gap + (sortObjects[i].boundsObject.maxY - sortObjects[i].boundsObject.minY));
            }
            move_state.bSamePos = false;
            move_state.onMouseUp({}, 0, 0, 0);
        }
    },


    Save_DocumentStateBeforeLoadChanges: function(oState)
    {
        var oTargetDocContent = this.getTargetDocContent(undefined, true);
        if(oTargetDocContent)
        {
            oState.Pos      = oTargetDocContent.GetContentPosition(false, false, undefined);
            oState.StartPos = oTargetDocContent.GetContentPosition(true, true, undefined);
            oState.EndPos   = oTargetDocContent.GetContentPosition(true, false, undefined);
            oState.DrawingSelection = oTargetDocContent.Selection.Use;
        }
        oState.DrawingsSelectionState = this.getSelectionState()[0];
        var oPos = this.getLeftTopSelectedObject2();
        oState.X = oPos.X;
        oState.Y = oPos.Y;
    },

    Load_DocumentStateAfterLoadChanges: function(oState)
    {
        this.clearPreTrackObjects();
        this.clearTrackObjects();
        this.resetSelection(undefined, undefined, true);
        this.changeCurrentState(new AscFormat.NullState(this));
        return this.loadDocumentStateAfterLoadChanges(oState);
    },

    loadDocumentStateAfterLoadChanges:  DrawingObjectsController.prototype.loadDocumentStateAfterLoadChanges,
    checkTrackDrawings:  DrawingObjectsController.prototype.checkTrackDrawings,
    isTrackingDrawings:  DrawingObjectsController.prototype.isTrackingDrawings,

    canChangeWrapPolygon: function()
    {
        return !this.selection.groupSelection && !this.selection.textSelection && !this.selection.chartSelection
            && this.selectedObjects.length === 1 && this.selectedObjects[0].canChangeWrapPolygon && this.selectedObjects[0].canChangeWrapPolygon() && !this.selectedObjects[0].parent.Is_Inline();
    },

    startChangeWrapPolygon: function()
    {
        if(this.canChangeWrapPolygon())
        {
            var bNeedBehindDoc = this.getCompatibilityMode() < AscCommon.document_compatibility_mode_Word15;
            if(this.selectedObjects[0].parent.wrappingType !== WRAPPING_TYPE_THROUGH
                || this.selectedObjects[0].parent.wrappingType !== WRAPPING_TYPE_TIGHT
            || this.selectedObjects[0].parent.behindDoc !== bNeedBehindDoc)
            {
                if(false === this.document.Document_Is_SelectionLocked(changestype_Drawing_Props, {Type : AscCommon.changestype_2_Element_and_Type , Element : this.selectedObjects[0].parent.Get_ParentParagraph(), CheckType : AscCommon.changestype_Paragraph_Content} ))
                {
                    this.document.StartAction(AscDFH.historydescription_Document_GrObjectsChangeWrapPolygon);
                    this.selectedObjects[0].parent.Set_WrappingType(WRAPPING_TYPE_TIGHT);
                    this.selectedObjects[0].parent.Set_BehindDoc(bNeedBehindDoc);
                    this.selectedObjects[0].parent.Check_WrapPolygon();
                    this.document.Recalculate();
                    this.document.UpdateInterface();
                    this.document.FinalizeAction();
                }
            }
            this.resetInternalSelection();
            this.selection.wrapPolygonSelection = this.selectedObjects[0];
            this.updateOverlay();
        }
    },


    removeById: function(nPageIdx, sId)
    {
        const oDrawing = AscCommon.g_oTableId.Get_ById(sId);
        if(isRealObject(oDrawing))
        {
            let bHdrFtr = oDrawing.isHdrFtrChild(false);
            if(!bHdrFtr)
            {
                let oPage = this.graphicPages[nPageIdx];
                if(isRealObject(oPage))
                {
                    oPage.delObjectById(sId);
                }
            }
        }
    },


    Remove_ById: function(id)
    {
        for(var i = 0; i < this.graphicPages.length; ++i)
        {
            this.removeById(i, id)
        }
    },


    selectById: function(id, pageIndex)
    {
        this.resetSelection();
        var obj = AscCommon.g_oTableId.Get_ById(id), nPageIndex = pageIndex;
        if(obj && obj.GraphicObj)
        {
            if(obj.isHdrFtrChild(false))
            {
                const oDocContent = obj.GetDocumentContent();
                if(oDocContent && oDocContent.GetAbsoluteStartPage() !== obj.PageNum)
                {
                    nPageIndex = obj.PageNum;
                }
            }
            else
            {
                if(AscFormat.isRealNumber(obj.PageNum))
                {
                    nPageIndex = obj.PageNum;
                }
            }
            obj.GraphicObj.select(this, nPageIndex);
        }

    },

    onChangeDrawingsSelection: function() 
    {
        
    },

    calculateAfterChangeTheme: function()
    {
        /*todo*/
        for(var i = 0; i < this.drawingObjects.length; ++i)
        {
            this.drawingObjects[i].calculateAfterChangeTheme();
        }
        editor.SyncLoadImages(this.urlMap);
        this.urlMap = [];
    },

    updateSelectionState: function()
    {
        return;
    },

    isChartSelection: function () 
    {
        var oSelectedor = this.selection.groupSelection ? this.selection.groupSelection : this;
        return AscCommon.isRealObject(oSelectedor.chartSelection);
    },

    getSmartArtSelection: function () {
        var groupSelection = this.selection.groupSelection;
        if (groupSelection && groupSelection.getObjectType() === AscDFH.historyitem_type_SmartArt) {
            return groupSelection;
        }
    },

    isTextSelectionInSmartArt: function ()
    {
        return !!this.getSmartArtSelection() && this.isTextSelectionUse();
    },


    drawSelectionPage: function(pageIndex)
    {
        var oMatrix = null;
        if(this.selection.textSelection)
        {

            if(this.selection.textSelection.selectStartPage === pageIndex)
            {
                if(this.selection.textSelection.transformText)
                {
                    oMatrix = this.selection.textSelection.transformText.CreateDublicate();
                }
                this.drawingDocument.UpdateTargetTransform(oMatrix);
                this.selection.textSelection.getDocContent().DrawSelectionOnPage(0);
            }
        }
        else if(this.selection.groupSelection)
        {
            if(this.selection.groupSelection.selectStartPage === pageIndex)
            {
                this.selection.groupSelection.drawSelectionPage(0);
            }
        }
        else if(this.selection.chartSelection && this.selection.chartSelection.selectStartPage === pageIndex && this.selection.chartSelection.selection.textSelection)
        {
            if(this.selection.chartSelection.selection.textSelection.transformText)
            {
                oMatrix = this.selection.chartSelection.selection.textSelection.transformText.CreateDublicate();
            }
            this.drawingDocument.UpdateTargetTransform(oMatrix);
            this.selection.chartSelection.selection.textSelection.getDocContent().DrawSelectionOnPage(0);
        }
    },
    getAllRasterImagesOnPage: function(pageIndex)
    {
        var ret = [];
        if(this.graphicPages[pageIndex])
        {
            var graphic_page = this.graphicPages[pageIndex];
            var hdr_ftr_page = this.getHdrFtrObjectsByPageIndex(pageIndex);

            var graphic_array = graphic_page.beforeTextObjects.concat(graphic_page.inlineObjects).concat(graphic_page.behindDocObjects);
            graphic_array = graphic_array.concat(hdr_ftr_page.beforeTextObjects).concat(hdr_ftr_page.inlineObjects).concat(hdr_ftr_page.behindDocObjects);
            for(var i = 0; i < graphic_array.length; ++i)
            {
                if(graphic_array[i].getAllRasterImages)
                    graphic_array[i].getAllRasterImages(ret);
            }
        }
        let oPageBg = this.document.Background;
        if(oPageBg && oPageBg.shape)
        {
            oPageBg.shape.getAllRasterImages(ret);
        }
        return ret;
    },

    checkChartTextSelection: DrawingObjectsController.prototype.checkChartTextSelection,
    checkNeedResetChartSelection: DrawingObjectsController.prototype.checkNeedResetChartSelection,


    addNewParagraph: DrawingObjectsController.prototype.addNewParagraph,


    paragraphClearFormatting: function(isClearParaPr, isClearTextPr)
    {
        this.applyDocContentFunction(CDocumentContent.prototype.ClearParagraphFormatting, [isClearParaPr, isClearTextPr], CTable.prototype.ClearParagraphFormatting);
    },

    applyDocContentFunction: DrawingObjectsController.prototype.applyDocContentFunction,
    applyTextFunction: DrawingObjectsController.prototype.applyTextFunction,

    setParagraphSpacing: DrawingObjectsController.prototype.setParagraphSpacing,

    setParagraphTabs: DrawingObjectsController.prototype.setParagraphTabs,

    setParagraphNumbering: DrawingObjectsController.prototype.setParagraphNumbering,

    setParagraphShd: DrawingObjectsController.prototype.setParagraphShd,


    setParagraphStyle:  DrawingObjectsController.prototype.setParagraphStyle,


    setParagraphContextualSpacing: DrawingObjectsController.prototype.setParagraphContextualSpacing,

    setParagraphPageBreakBefore: DrawingObjectsController.prototype.setParagraphPageBreakBefore,
    setParagraphKeepLines: DrawingObjectsController.prototype.setParagraphKeepLines,

    setParagraphKeepNext: DrawingObjectsController.prototype.setParagraphKeepNext,


    setParagraphWidowControl: DrawingObjectsController.prototype.setParagraphWidowControl,

    setParagraphBorders: DrawingObjectsController.prototype.setParagraphBorders,

    paragraphAdd: DrawingObjectsController.prototype.paragraphAdd,

    paragraphIncDecFontSize: DrawingObjectsController.prototype.paragraphIncDecFontSize,

    paragraphIncDecIndent: DrawingObjectsController.prototype.paragraphIncDecIndent,

    setParagraphAlign: DrawingObjectsController.prototype.setParagraphAlign,

    setParagraphIndent: DrawingObjectsController.prototype.setParagraphIndent,
    getSelectedObjectsBounds: DrawingObjectsController.prototype.getSelectedObjectsBounds,
    getContextMenuPosition: DrawingObjectsController.prototype.getContextMenuPosition,
    getLeftTopSelectedFromArray: DrawingObjectsController.prototype.getLeftTopSelectedFromArray,
    getObjectForCrop: DrawingObjectsController.prototype.getObjectForCrop,
    canStartImageCrop: DrawingObjectsController.prototype.canStartImageCrop,
    startImageCrop: DrawingObjectsController.prototype.startImageCrop,
    endImageCrop: DrawingObjectsController.prototype.endImageCrop,
    cropFit: DrawingObjectsController.prototype.cropFit,
    cropFill: DrawingObjectsController.prototype.cropFill,

    checkRedrawOnChangeCursorPosition: DrawingObjectsController.prototype.checkRedrawOnChangeCursorPosition,

    getFromTargetTextObjectContextMenuPosition: function(oTargetTextObject, pageIndex)
    {
        var dPosX = this.document.TargetPos.X, dPosY = this.document.TargetPos.Y, oTransform = oTargetTextObject.transformText;
        return {X: oTransform.TransformPointX(dPosX, dPosY), Y: oTransform.TransformPointY(dPosX, dPosY), PageIndex: this.document.TargetPos.PageNum};
    },

    getLeftTopSelectedObject: function(pageIndex)
    {
        if(this.selectedObjects.length > 0)
        {
            var oRes = this.getLeftTopSelectedObjectByPage(pageIndex);
            if(oRes.bSelected === true)
            {
                return oRes;
            }
            var aSelectedObjectsCopy = [].concat(this.selectedObjects);
            aSelectedObjectsCopy.sort(function(a, b){return a.selectStartPage - b.selectStartPage});
            return this.getLeftTopSelectedObjectByPage(aSelectedObjectsCopy[0].selectStartPage);
        }
        return {X: 0, Y: 0, PageIndex: pageIndex};
    },

    getLeftTopSelectedObject2: function()
    {
        if(this.selectedObjects.length > 0)
        {
            var aSelectedObjectsCopy = [].concat(this.selectedObjects);
            aSelectedObjectsCopy.sort(function(a, b){return a.selectStartPage - b.selectStartPage});
            return this.getLeftTopSelectedObjectByPage(aSelectedObjectsCopy[0].selectStartPage);
        }
        return {X: 0, Y: 0, PageIndex: 0};
    },

    getLeftTopSelectedObjectByPage: function(pageIndex)
    {
        var oDrawingPage, oRes;
        if(this.document.GetDocPosType() === docpostype_HdrFtr)
        {
            if(this.graphicPages[pageIndex])
            {
                oDrawingPage = this.graphicPages[pageIndex].hdrFtrPage;
            }
        }
        else
        {
            if(this.graphicPages[pageIndex])
            {
                oDrawingPage = this.graphicPages[pageIndex];
            }
        }
        if(oDrawingPage)
        {
            oRes = this.getLeftTopSelectedFromArray(oDrawingPage.beforeTextObjects, pageIndex);
            if(oRes.bSelected)
            {
                return oRes;
            }
            oRes = this.getLeftTopSelectedFromArray(oDrawingPage.inlineObjects, pageIndex);
            if(oRes.bSelected)
            {
                return oRes;
            }
            oRes = this.getLeftTopSelectedFromArray(oDrawingPage.behindDocObjects, pageIndex);
            if(oRes.bSelected)
            {
                return oRes;
            }
        }
        return {X: 0, Y: 0, PageIndex: pageIndex};
    },



    CheckRange: function(X0, Y0, X1, Y1, Y0Sp, Y1Sp, LeftField, RightField, PageNum, HdrFtrRanges, docContent, bMathWrap)
    {
        if(isRealObject(this.graphicPages[PageNum]))
        {
            var Ranges = this.graphicPages[PageNum].CheckRange(X0, Y0, X1, Y1, Y0Sp, Y1Sp, LeftField, RightField, HdrFtrRanges, docContent, bMathWrap);

            var ResultRanges = [];

            // Уберем лишние отрезки
            var Count = Ranges.length;
            for ( var Index = 0; Index < Count; Index++ )
            {
                var Range = Ranges[Index];

                if ( Range.X1 > X0 && Range.X0 < X1 )
                {
                    Range.X0 = Math.max( X0, Range.X0 );
                    Range.X1 = Math.min( X1, Range.X1 );

                    ResultRanges.push( Range );
                }
            }

            return ResultRanges;
        }
        return HdrFtrRanges;
    },

    getTableProps: function()
    {
        var content = this.getTargetDocContent();
        if(content)
            return content.Interface_Update_TablePr( true );

        return null;
    },

    startAddShape: function(preset)
    {
        switch(preset)
        {
            case "spline":
            {
                this.changeCurrentState(new AscFormat.SplineBezierState(this));
                break;
            }
            case "polyline1":
            {
                this.changeCurrentState(new AscFormat.PolyLineAddState(this));
                break;
            }
            case "polyline2":
            {
                this.changeCurrentState(new AscFormat.AddPolyLine2State(this));
                break;
            }
            default :
            {
                this.changeCurrentState(new AscFormat.StartAddNewShape(this, preset));
                break;
            }
        }
		this.saveDocumentState();
    },
    endTrackNewShape: DrawingObjectsController.prototype.endTrackNewShape
};
CGraphicObjects.prototype.constructor = CGraphicObjects;
CGraphicObjects.prototype.saveDocumentState = function() {
	this.startDocState = null;
	if(!this.document) {
		return;
	}
	this.startDocState = this.document.SaveDocumentState(false);
};
CGraphicObjects.prototype.Document_Is_SelectionLocked = function(CheckType)
{
    if(CheckType === AscCommon.changestype_ColorScheme)
    {
        this.Lock.Check(this.Get_Id());
    }
};
CGraphicObjects.prototype.documentIsSelectionLocked = function(CheckType)
{
	var oDocContent = this.getTargetDocContent();

    var oDrawing, i;
    var bDelete = (AscCommon.changestype_Delete === CheckType || AscCommon.changestype_Remove === CheckType);

    if(AscCommon.changestype_Drawing_Props === CheckType
        || AscCommon.changestype_Image_Properties === CheckType
        || AscCommon.changestype_Delete === CheckType
        || AscCommon.changestype_Remove === CheckType
        || AscCommon.changestype_Paragraph_Content === CheckType
        || AscCommon.changestype_Paragraph_TextProperties === CheckType
        || AscCommon.changestype_Paragraph_AddText === CheckType
        || AscCommon.changestype_ContentControl_Add === CheckType
        || AscCommon.changestype_Paragraph_Properties === CheckType
        || AscCommon.changestype_Document_Content_Add === CheckType)
    {
        for(i = 0; i < this.selectedObjects.length; ++i)
        {
            oDrawing = this.selectedObjects[i].parent;
            if(bDelete && !oDocContent)
            {
                oDrawing.CheckDeletingLock();
            }
            oDrawing.Lock.Check(oDrawing.Get_Id());
        }
    }

    if (oDocContent)
        oDocContent.Document_Is_SelectionLocked(CheckType);
};
CGraphicObjects.prototype.getAnimationPlayer = function()
{
    return null;
};

CGraphicObjects.prototype.getImageDataFromSelection = DrawingObjectsController.prototype.getImageDataFromSelection;
CGraphicObjects.prototype.putImageToSelection = function(sImageUrl, nWidth, nHeight, replaceMode)
{
    let aSelectedObjects = this.getSelectedArray();
    if(aSelectedObjects.length > 0 && aSelectedObjects[0].isImage())
    {
        let oController = this;
        this.checkSelectedObjectsAndCallback(function() {
            let dWidth = nWidth * AscCommon.g_dKoef_pix_to_mm;
            let dHeight = nHeight * AscCommon.g_dKoef_pix_to_mm;
            let oSp = aSelectedObjects[0];
            oSp.replacePictureData(sImageUrl, dWidth, dHeight, true, replaceMode);
            if(oSp.group)
            {
                oController.selection.groupSelection.resetInternalSelection();
                oSp.group.selectObject(oSp, 0);
            }
            else
            {
                oController.resetSelection();
                oController.selectObject(oSp, 0);
            }
        }, [], false, 0, []);
    }
    else
    {
        if (false === this.document.Document_Is_SelectionLocked(AscCommon.changestype_Paragraph_Content))
        {
            let oImageData =
            {
                src: sImageUrl,
                Image:
                {
                    width: nWidth,
                    height: nHeight
                }
            };
            this.document.StartAction();
            if(aSelectedObjects.length > 0)
            {
                this.document.Remove(-1)
            }
            this.document.AddImages([oImageData]);
            this.document.FinalizeAction();

        }
    }
};
CGraphicObjects.prototype.getPluginSelectionInfo = function()
{
    return DrawingObjectsController.prototype.getPluginSelectionInfo.call(this);
};
CGraphicObjects.prototype.getSelectionImageData = DrawingObjectsController.prototype.getSelectionImageData;
CGraphicObjects.prototype.getImageDataForSaving = DrawingObjectsController.prototype.getImageDataForSaving;
CGraphicObjects.prototype.getPresentation = DrawingObjectsController.prototype.getPresentation;

CGraphicObjects.prototype.getHorGuidesPos = function() {
    return [];
}
CGraphicObjects.prototype.getVertGuidesPos = function() {
    return [];
};
CGraphicObjects.prototype.hitInGuide = function(x, y) {
    return null;
};
CGraphicObjects.prototype.onInkDrawerChangeState = DrawingObjectsController.prototype.onInkDrawerChangeState;
CGraphicObjects.prototype.setDrawingDocPosType = function() {
	const oDoc = this.document;
	if(oDoc && false == this.api.isDocumentRenderer()) {
		if (AscCommonWord.docpostype_HdrFtr !== oDoc.CurPos.Type) {
			oDoc.SetDocPosType(AscCommonWord.docpostype_DrawingObjects);
			oDoc.Selection.Use   = true;
			oDoc.Selection.Start = true;
		}
		else {
			oDoc.Selection.Use   = true;
			oDoc.Selection.Start = true;

			const CurHdrFtr             = oDoc.HdrFtr.CurHdrFtr;
			const DocContent            = CurHdrFtr.Content;

			DocContent.SetDocPosType(AscCommonWord.docpostype_DrawingObjects);
			DocContent.Selection.Use   = true;
			DocContent.Selection.Start = true;
		}
	}
};
CGraphicObjects.prototype.checkInkState = function() {
	if(!this.document) {
		return;
	}
	// if(AscCommonWord.docpostype_HdrFtr === this.document.CurPos.Type) {
	// 	return;
	// }
	DrawingObjectsController.prototype.checkInkState.call(this);
	const oAPI = this.getEditorApi();
	if(oAPI.isInkDrawerOn()) {
		this.setDrawingDocPosType();
	}
};

CGraphicObjects.prototype.saveStartDocState = function() {
	if(this.document) {

	}
};

function ComparisonByZIndexSimpleParent(obj1, obj2)
{
    if(obj1.parent && obj2.parent)
        return ComparisonByZIndexSimple(obj1.parent, obj2.parent);
    return 0;
}

function ComparisonByZIndexSimple(obj1, obj2)
{
    if(AscFormat.isRealNumber(obj1.RelativeHeight) && AscFormat.isRealNumber(obj2.RelativeHeight))
    {
        if(obj1.RelativeHeight === obj2.RelativeHeight)
        {
            if(editor && editor.WordControl && editor.WordControl.m_oLogicDocument)
            {
                return editor.WordControl.m_oLogicDocument.CompareDrawingsLogicPositions(obj2, obj1);
            }
        }
        return obj1.RelativeHeight - obj2.RelativeHeight;
    }
    if(!AscFormat.isRealNumber(obj1.RelativeHeight) && AscFormat.isRealNumber(obj2.RelativeHeight))
        return -1;
    if(AscFormat.isRealNumber(obj1.RelativeHeight) && !AscFormat.isRealNumber(obj2.RelativeHeight))
        return 1;
    return 0;
}

//--------------------------------------------------------export----------------------------------------------------
window['AscCommonWord'] = window['AscCommonWord'] || {};
window['AscCommonWord'].CGraphicObjects = CGraphicObjects;