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

"use strict";

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

// Import

		var c_oAscSizeRelFromH = AscCommon.c_oAscSizeRelFromH;
		var c_oAscSizeRelFromV = AscCommon.c_oAscSizeRelFromV;
		var CMatrix = AscCommon.CMatrix;
		var isRealObject = AscCommon.isRealObject;
		var global_mouseEvent = AscCommon.global_mouseEvent;
		var global_MatrixTransformer = AscCommon.global_MatrixTransformer;

		var checkNormalRotate = AscFormat.checkNormalRotate;
		var HitInLine = AscFormat.HitInLine;
		var MOVE_DELTA = AscFormat.MOVE_DELTA;


		var pHText = [];

		pHText[AscFormat.phType_body] = "Slide text";             //"Текст слайда" ;                              ;
		pHText[AscFormat.phType_chart] = "Chart";         // "Диаграмма" ;                                     ;
		pHText[AscFormat.phType_clipArt] = "Clip Art";// "Текст слайда" ; //(Clip Art)                   ;
		pHText[AscFormat.phType_ctrTitle] = "Slide title";// "Заголовок слайда" ; //(Centered Title)     ;
		pHText[AscFormat.phType_dgm] = "Diagram";// "Диаграмма";// (Diagram)                        ;
		pHText[AscFormat.phType_dt] = "Date and time";// "Дата и время";// (Date and Time)         ;
		pHText[AscFormat.phType_ftr] = "Footer";// "Нижний колонтитул";// (Footer)                  ;
		pHText[AscFormat.phType_hdr] = "Header";// "Верхний колонтитул"; //(Header)                 ;
		pHText[AscFormat.phType_media] = "Media";// "Текст слайда"; //(Media)                         ;
		pHText[AscFormat.phType_obj] = "Slide text";// "Текст слайда"; //(Object)                   ;
		pHText[AscFormat.phType_pic] = "Picture";// "Вставка рисунка"; //(Picture)                  ;
		pHText[AscFormat.phType_sldImg] = "Image";// "Вставка рисунка"; //(Slide Image)                ;
		pHText[AscFormat.phType_sldNum] = "Slide number";// "Номер слайда"; //(Slide Number)           ;
		pHText[AscFormat.phType_subTitle] = "Slide subtitle";// "Подзаголовок слайда"; //(Subtitle)      ;
		pHText[AscFormat.phType_tbl] = "Table";// "Таблица"; //(Table)                              ;
		pHText[AscFormat.phType_title] = "Slide title";// "Заголовок слайда" ;  //(Title)             ;

		var c_oAscFill = Asc.c_oAscFill;

		var dTextFitDelta = 3;// mm

		function getSmartArtParagraphIndent(fontSize) {
			if (fontSize >= 30) {
				return 7.9;
			}
			if (fontSize >= 20) {
				return 6.4;
			}
			if (fontSize >= 16) {
				return 4.8;
			}
			if (fontSize >= 12) {
				return 3.2;
			}
			return 1.6;
		}

		function CheckObjectLine(obj) {
			return (obj instanceof CShape && obj.spPr && obj.spPr.geometry && AscFormat.CheckLinePresetForParagraphAdd(obj.spPr.geometry.preset));
		}


		function CheckWordArtTextPr(oRun) {
			if (oRun instanceof AscCommonWord.ParaRun) {
				var oTextPr = oRun.Get_CompiledPr();
				if (oTextPr.TextFill || (oTextPr.TextOutline && oTextPr.TextOutline.isVisible()) ||
					(oTextPr.Unifill && oTextPr.Unifill.fill && (oTextPr.Unifill.fill.type !== c_oAscFill.FILL_TYPE_SOLID || oTextPr.Unifill.transparent != null && oTextPr.Unifill.transparent < 254.5)))
					return true;
			}
			return false;
		}


		function hitInRect(x, y, l, t, r, b) {
			return x >= l && x <= r && y >= t && y <= b;
		}

		function hitToCropHandles(x, y, object) {
			var invert_transform = object.getInvertTransform();
			if (!invert_transform) {
				return -1;
			}
			var t_x, t_y;
			t_x = invert_transform.TransformPointX(x, y);
			t_y = invert_transform.TransformPointY(x, y);
			var fCoeff = object.convertPixToMM(1);
			var fCoeff2 = 1 / fCoeff;


			var widthCorner = (object.extX * fCoeff2 + 1) >> 1;
			var isCentralMarkerX = widthCorner > 40;
			if (widthCorner > 17)
				widthCorner = 17;
			var heightCorner = (object.extY * fCoeff2 + 1) >> 1;
			var isCentralMarkerY = heightCorner > 40;
			if (heightCorner > 17)
				heightCorner = 17;

			widthCorner *= fCoeff;
			heightCorner *= fCoeff;
			var markerWidth = 5 * fCoeff;

			if (hitInRect(t_x, t_y, 0, 0, widthCorner, markerWidth)) {
				return 0;
			}
			if (hitInRect(t_x, t_y, 0, 0, markerWidth, heightCorner)) {
				return 0;
			}

			if (isCentralMarkerX) {
				if (hitInRect(t_x, t_y, object.extX / 2 - widthCorner / 2, 0, object.extX / 2 + widthCorner / 2, markerWidth)) {
					return 1;
				}
				if (hitInRect(t_x, t_y, object.extX / 2 - widthCorner / 2, object.extY - markerWidth, object.extX / 2 + widthCorner / 2, object.extY)) {
					return 5;
				}
			}

			if (hitInRect(t_x, t_y, object.extX - widthCorner, 0, object.extX, markerWidth)) {
				return 2;
			}
			if (hitInRect(t_x, t_y, object.extX - markerWidth, 0, object.extX, heightCorner)) {
				return 2;
			}

			if (isCentralMarkerY) {
				if (hitInRect(t_x, t_y, object.extX - markerWidth, object.extY / 2 - heightCorner / 2, object.extX, object.extY / 2 + heightCorner / 2)) {
					return 3;
				}
				if (hitInRect(t_x, t_y, 0, object.extY / 2 - heightCorner / 2, markerWidth, object.extY / 2 + heightCorner / 2)) {
					return 7;
				}
			}

			if (hitInRect(t_x, t_y, object.extX - markerWidth, object.extY - heightCorner, object.extX, object.extY)) {
				return 4;
			}
			if (hitInRect(t_x, t_y, object.extX - widthCorner, object.extY - markerWidth, object.extX, object.extY)) {
				return 4;
			}

			if (hitInRect(t_x, t_y, 0, object.extY - heightCorner, markerWidth, object.extY)) {
				return 6;
			}
			if (hitInRect(t_x, t_y, 0, object.extY - markerWidth, widthCorner, object.extY)) {
				return 6;
			}

			return -1;

		}

		function hitToHandles(x, y, object) {
			var oApi = Asc.editor || editor;
			var isDrawHandles = oApi ? oApi.isShowShapeAdjustments() : true;

			if (isDrawHandles && object && object.isForm && object.isForm() && object.getInnerForm() && object.getInnerForm().IsFormLocked())
				isDrawHandles = false;

			if (Asc.editor.isPdfEditor() && Asc.editor.getPDFDoc().IsViewerObject(object)) {
				isDrawHandles = true;
			}

			if (isDrawHandles === false) {
				return -1;
			}

			if(object.canResize && !object.canResize()) {
				return -1;
			}

			if (object.cropObject) {
				return hitToCropHandles(x, y, object);
			}
			var invert_transform = object.getInvertTransform();
			if (!invert_transform) {
				return -1;
			}
			var t_x, t_y;
			t_x = invert_transform.TransformPointX(x, y);
			t_y = invert_transform.TransformPointY(x, y);
			var radius = object.convertPixToMM(AscCommon.TRACK_CIRCLE_RADIUS);

			if (typeof global_mouseEvent !== "undefined" && isRealObject(global_mouseEvent) && AscFormat.isRealNumber(global_mouseEvent.KoefPixToMM)) {
				radius *= global_mouseEvent.KoefPixToMM;
			}

			if (global_mouseEvent && global_mouseEvent.AscHitToHandlesEpsilon) {
				radius = global_mouseEvent.AscHitToHandlesEpsilon;
			}

			// чтобы не считать корни
			radius *= radius;

			// считаем ближайший маркер, так как окрестность может быть большой, и пересекаться.

			var _min_dist = 2 * radius; // главное что больше
			var _ret_value = -1;

			var check_line = CheckObjectLine(object);

			var sqr_x = t_x * t_x, sqr_y = t_y * t_y;
			var _tmp_dist = sqr_x + sqr_y;
			if (_tmp_dist < _min_dist) {
				_min_dist = _tmp_dist;
				_ret_value = 0;
			}

			var hc = object.extX * 0.5;
			var dist_x = t_x - hc;
			sqr_x = dist_x * dist_x;
			_tmp_dist = sqr_x + sqr_y;
			if (_tmp_dist < _min_dist && !check_line) {
				_min_dist = _tmp_dist;
				_ret_value = 1;
			}

			dist_x = t_x - object.extX;
			sqr_x = dist_x * dist_x;
			_tmp_dist = sqr_x + sqr_y;
			if (_tmp_dist < _min_dist && !check_line) {
				_min_dist = _tmp_dist;
				_ret_value = 2;
			}

			var vc = object.extY * 0.5;
			var dist_y = t_y - vc;
			sqr_y = dist_y * dist_y;
			_tmp_dist = sqr_x + sqr_y;
			if (_tmp_dist < _min_dist && !check_line) {
				_min_dist = _tmp_dist;
				_ret_value = 3;
			}

			dist_y = t_y - object.extY;
			sqr_y = dist_y * dist_y;
			_tmp_dist = sqr_x + sqr_y;
			if (_tmp_dist < _min_dist) {
				_min_dist = _tmp_dist;
				_ret_value = 4;
			}

			dist_x = t_x - hc;
			sqr_x = dist_x * dist_x;
			_tmp_dist = sqr_x + sqr_y;
			if (_tmp_dist < _min_dist && !check_line) {
				_min_dist = _tmp_dist;
				_ret_value = 5;
			}

			dist_x = t_x;
			sqr_x = dist_x * dist_x;
			_tmp_dist = sqr_x + sqr_y;
			if (_tmp_dist < _min_dist && !check_line) {
				_min_dist = _tmp_dist;
				_ret_value = 6;
			}

			dist_y = t_y - vc;
			sqr_y = dist_y * dist_y;
			_tmp_dist = sqr_x + sqr_y;
			if (_tmp_dist < _min_dist && !check_line) {
				_min_dist = _tmp_dist;
				_ret_value = 7;
			}

			if (object.canRotate && object.canRotate() && !check_line) {
				var rotate_distance = object.convertPixToMM(AscCommon.TRACK_DISTANCE_ROTATE);
				dist_y = t_y + rotate_distance;
				sqr_y = dist_y * dist_y;
				dist_x = t_x - hc;
				sqr_x = dist_x * dist_x;

				_tmp_dist = sqr_x + sqr_y;
				if (_tmp_dist < _min_dist) {
					_min_dist = _tmp_dist;
					_ret_value = 8;
				}
			}

			// теперь смотрим расстояние до центра фигуры, чтобы можно было двигать маленькую
			dist_x = t_x - hc;
			dist_y = t_y - vc;
			_tmp_dist = dist_x * dist_x + dist_y * dist_y;
			if (_tmp_dist < _min_dist && !check_line) {
				_min_dist = _tmp_dist;
				_ret_value = -1;
			}

			// can resize only on corners
			if ([1, 3, 5, 7].includes(_ret_value) && (object.IsAnnot && object.IsAnnot() && object.IsStamp()) && object.getNoChangeAspect()) {
				return -1;
			}

			if (_min_dist < radius)
				return _ret_value;

			return -1;
		}

		function CreateUniFillByUniColorCopy(uniColor) {
			var ret = new AscFormat.CUniFill();
			ret.setFill(new AscFormat.CSolidFill());
			ret.fill.setColor(uniColor.createDuplicate());
			return ret;
		}

		function CreateUniFillByUniColor(uniColor) {
			var ret = new AscFormat.CUniFill();
			ret.setFill(new AscFormat.CSolidFill());
			ret.fill.setColor(uniColor);
			return ret;
		}

		function CopyPresentationFieldToPPTX(oOldPF, oParagraph) {
			const oPF = new AscCommonWord.CPresentationField(oParagraph);
			oPF.Set_Pr( oOldPF.Pr.Copy() );
			oPF.SetGuid(AscCommon.CreateGUID());
			oPF.SetFieldType( oOldPF.FieldType );
			if(oOldPF.PPr)
			{
				oPF.SetPPr(oOldPF.PPr.Copy());
			}

			oPF.CanAddToContent = true;
			for (let CurPos = 0; CurPos < oOldPF.Content.length; CurPos++) {
				const oItem = oOldPF.Content[CurPos];
				oPF.Add_ToContent(CurPos, oItem.Copy(), false);
			}
			oPF.CanAddToContent = false;
			return oPF;
		}
		function CopyRunToPPTX(Run, Paragraph, bHyper) {
			var NewRun = new ParaRun(Paragraph, false);
			var RunPr = Run.Pr.Copy();
			if (RunPr.RStyle != undefined) {
				RunPr.RStyle = undefined;
			}
			RunPr.FontScale = undefined;

			if (bHyper) {
				if (!RunPr.Unifill) {
					RunPr.Unifill = AscFormat.CreateUniFillSchemeColorWidthTint(11, 0);
				}
				RunPr.Underline = true;
			}
			if (RunPr.TextFill) {
				RunPr.Unifill = RunPr.TextFill;
				RunPr.TextFill = undefined;
			}

			NewRun.Set_Pr(RunPr);

			var PosToAdd = 0;
			for (var CurPos = 0; CurPos < Run.Content.length; CurPos++) {
				var Item = Run.Content[CurPos];
				if (Item.Type !== para_End && Item.Type !== para_Drawing && Item.Type !== para_Comment
					&& Item.Type !== para_PageCount && Item.Type !== para_FootnoteRef && Item.Type !== para_FootnoteReference
					&& Item.Type !== para_PageNum && Item.Type !== para_FieldChar && Item.Type !== para_Bookmark
					&& Item.Type !== para_RevisionMove && Item.Type !== para_InstrText
					&& Item.Type !== para_EndnoteReference && Item.Type !== para_EndnoteRef) {
					NewRun.Add_ToContent(PosToAdd, Item.Copy(), false);
					++PosToAdd;
				}
			}
			return NewRun;
		}


		function ConvertParagraphContentToPPTX(aOrigContent, oNewParagraph, bIsAddMath, bRemoveHyperlink) {
			var Count = aOrigContent.length;
			for (var Index = 0; Index < Count; Index++) {
				var Item = aOrigContent[Index];
				if (Item instanceof AscCommonWord.CPresentationField) {
					oNewParagraph.Internal_Content_Add(oNewParagraph.Content.length, CopyPresentationFieldToPPTX(Item, oNewParagraph), false);
				} else if (Item.Type === para_Run) {
					oNewParagraph.Internal_Content_Add(oNewParagraph.Content.length, CopyRunToPPTX(Item, oNewParagraph), false);
				} else if (Item.Type === para_Hyperlink) {
					if (bRemoveHyperlink === true) {
						for (var j = 0; j < Item.Content.length; ++j) {
							if (Item.Content[j].Type === para_Run) {
								oNewParagraph.Internal_Content_Add(oNewParagraph.Content.length, CopyRunToPPTX(Item.Content[j], oNewParagraph), false);
							}
						}
					} else {
						var aChildContent = ConvertHyperlinkToPPTX(Item, oNewParagraph);
						for (var nChildIdx = 0; nChildIdx < aChildContent.length; ++nChildIdx) {
							oNewParagraph.Internal_Content_Add(oNewParagraph.Content.length, aChildContent[nChildIdx], false);
						}
					}

				} else if (Item.Type === para_InlineLevelSdt) {
					ConvertParagraphContentToPPTX(Item.Content, oNewParagraph, bIsAddMath, bRemoveHyperlink)
				} else if (true === bIsAddMath && Item.Type === para_Math) {
					oNewParagraph.Internal_Content_Add(oNewParagraph.Content.length, Item.Copy(), false);
				}
			}
		}

		function ConvertParagraphToPPTX(paragraph, drawingDocument, newParent, bIsAddMath, bRemoveHyperlink) {
			var _drawing_document = isRealObject(drawingDocument) ? drawingDocument : paragraph.DrawingDocument;
			var _new_parent = isRealObject(newParent) ? newParent : null;

			var new_paragraph = new AscWord.Paragraph(_new_parent, true);
			if (!(paragraph instanceof AscWord.Paragraph))
				return new_paragraph;
			var oCopyPr = paragraph.Pr.Copy();

			oCopyPr.ContextualSpacing = undefined;
			oCopyPr.KeepLines = undefined;
			oCopyPr.KeepNext = undefined;
			oCopyPr.PageBreakBefore = undefined;
			oCopyPr.Shd = undefined;
			oCopyPr.Brd.First = undefined;
			oCopyPr.Brd.Last = undefined;
			oCopyPr.Brd.Between = undefined;
			oCopyPr.Brd.Bottom = undefined;
			oCopyPr.Brd.Left = undefined;
			oCopyPr.Brd.Right = undefined;
			oCopyPr.Brd.Top = undefined;
			oCopyPr.WidowControl = undefined;
			oCopyPr.Tabs = undefined;
			oCopyPr.NumPr = undefined;
			oCopyPr.PStyle = undefined;
			oCopyPr.FramePr = undefined;


			new_paragraph.Set_Pr(oCopyPr);
			var oNewEndPr = paragraph.TextPr.Value.Copy();
			if (oNewEndPr.TextFill) {
				oNewEndPr.Unifill = oNewEndPr.TextFill;
				oNewEndPr.TextFill = undefined;
			}
			if (oNewEndPr.RStyle != undefined) {
				oNewEndPr.RStyle = undefined;
			}
			oNewEndPr.FontScale = undefined;
			new_paragraph.TextPr.Set_Value(oNewEndPr);
			new_paragraph.Internal_Content_Remove2(0, new_paragraph.Content.length);
			ConvertParagraphContentToPPTX(paragraph.Content, new_paragraph, bIsAddMath, bRemoveHyperlink);
			var EndRun = new ParaRun(new_paragraph);
			EndRun.Add_ToContent(0, new AscWord.CRunParagraphMark());
			new_paragraph.Internal_Content_Add(new_paragraph.Content.length, EndRun, false);
			return new_paragraph;
		}


		function ConvertElementsToPPTX(aResult, aElements, drawingDocument, newParent, bIsAddMath, bRemoveHyperlink) {
			var i, j, oElement;
			for (i = 0; i < aElements.length; ++i) {
				oElement = aElements[i];
				if (oElement instanceof AscWord.Paragraph) {
					aResult.push(ConvertParagraphToPPTX(oElement));
				} else if (oElement instanceof AscCommonWord.CTable) {
					var paragraphs = [];
					oElement.GetAllParagraphs({All: true}, paragraphs);
					for (j = 0; j < paragraphs.length; j++) {
						aResult.push(AscFormat.ConvertParagraphToPPTX(paragraphs[j], drawingDocument,
							newParent, bIsAddMath, bRemoveHyperlink));
					}
				} else if (oElement instanceof AscCommonWord.CBlockLevelSdt) {
					ConvertElementsToPPTX(aResult, oElement.Content.Content, drawingDocument, newParent, bIsAddMath, bRemoveHyperlink)
				}
			}
		}

		function ConvertHyperlinkToPPTX(hyperlink, paragraph) {
			var hyperlink_ret = new ParaHyperlink(), i, item, pos = 0;
			hyperlink_ret.SetValue(hyperlink.Value);
			hyperlink_ret.SetToolTip(hyperlink.ToolTip);
			for (i = 0; i < hyperlink.Content.length; ++i) {
				item = hyperlink.Content[i];
				if (item.Type === para_Run) {
					hyperlink_ret.Add_ToContent(pos++, CopyRunToPPTX(item, paragraph, true));
				} else if (item.Type === para_Hyperlink) {
					var aConvertedContent = ConvertHyperlinkToPPTX(item, paragraph);
					for (var nChildIdx = 0; nChildIdx < aConvertedContent.length; ++nChildIdx) {
						hyperlink_ret.Add_ToContent(pos++, aConvertedContent[nChildIdx]);
					}
				}
			}
			if (typeof hyperlink.Value === "string" && hyperlink.Value.length > Asc.c_nMaxHyperlinkLength) {
				return hyperlink_ret.Content;
			}
			return [hyperlink_ret];
		}

		function ConvertParagraphToWord(paragraph, docContent) {
			var _docContent = isRealObject(docContent) ? docContent : paragraph.Parent;
			var oldFlag = paragraph.bFromDocument;
			paragraph.bFromDocument = true;
			var new_paragraph = paragraph.Copy(_docContent);
			CheckWordParagraphContent(new_paragraph.Content, new_paragraph.Pr.DefaultRunPr);
			var NewRPr = CheckWordRunPr(new_paragraph.TextPr.Value);
			var oCopyDefaultPr;
			if (NewRPr) {
				if (new_paragraph.Pr.DefaultRunPr) {
					oCopyDefaultPr = new_paragraph.Pr.DefaultRunPr.Copy();
					oCopyDefaultPr.Merge(NewRPr);
					NewRPr = CheckWordRunPr(oCopyDefaultPr);
					if (!NewRPr) {
						NewRPr = oCopyDefaultPr;
					}
				}
				new_paragraph.TextPr.Apply_TextPr(NewRPr);
			} else {
				if (new_paragraph.Pr.DefaultRunPr) {
					oCopyDefaultPr = new_paragraph.Pr.DefaultRunPr.Copy();
					oCopyDefaultPr.Merge(new_paragraph.TextPr.Value);
					NewRPr = CheckWordRunPr(oCopyDefaultPr);
					if (!NewRPr) {
						NewRPr = oCopyDefaultPr;
					}
					new_paragraph.TextPr.Apply_TextPr(NewRPr);
				}
			}
			paragraph.bFromDocument = oldFlag;
			return new_paragraph;
		}

		function CheckWordRunPr(Pr, bMath) {
			var NewRPr = null;
			if (Pr.Unifill && Pr.Unifill.fill) {
				switch (Pr.Unifill.fill.type) {
					case c_oAscFill.FILL_TYPE_SOLID: {
						if (Pr.Unifill.fill.color && Pr.Unifill.fill.color.color) {
							switch (Pr.Unifill.fill.color.color.type) {
								case Asc.c_oAscColor.COLOR_TYPE_SCHEME: {
									if (Pr.Unifill.fill.color.Mods && Pr.Unifill.fill.color.Mods.Mods.length !== 0) {
										if (!Pr.Unifill.fill.color.canConvertPPTXModsToWord()) {
											NewRPr = Pr.Copy();
											NewRPr.TextFill = NewRPr.Unifill;
											NewRPr.Unifill = undefined;
										} else {
											NewRPr = Pr.Copy();
											NewRPr.Unifill.convertToWordMods();
										}
									}
									break;
								}
								case Asc.c_oAscColor.COLOR_TYPE_SRGB: {

									NewRPr = Pr.Copy();
									var RGBA = Pr.Unifill.fill.color.color.RGBA;
									NewRPr.Color = new CDocumentColor(RGBA.R, RGBA.G, RGBA.B);
									NewRPr.Unifill = undefined;
									break;
								}
								default: {
									NewRPr = Pr.Copy();
									NewRPr.TextFill = NewRPr.Unifill;
									NewRPr.Unifill = undefined;
								}
							}
						}
						break;
					}
					case c_oAscFill.FILL_TYPE_PATT:
					case c_oAscFill.FILL_TYPE_BLIP: {
						NewRPr = Pr.Copy();
						NewRPr.TextFill = AscFormat.CreateUnfilFromRGB(0, 0, 0);
						NewRPr.Unifill = undefined;
						break;
					}
					default : {
						NewRPr = Pr.Copy();
						NewRPr.TextFill = NewRPr.Unifill;
						NewRPr.Unifill = undefined;
						break;
					}
				}
			}

			if (bMath) {
				NewRPr = Pr.Copy();
				NewRPr.RFonts.SetAll("Cambria Math", -1);
			}
			return NewRPr;
		}

		function CheckWordParagraphContent(aContent, oTextPr) {
			var NewRPr, MergePr;
			for (var i = 0; i < aContent.length; ++i) {
				var oItem = aContent[i];
				switch (oItem.Type) {
					case para_Run: {
						NewRPr = CheckWordRunPr(oItem.Pr);
						if (NewRPr) {
							MergePr = NewRPr;
							if (oTextPr) {
								MergePr = oTextPr.Copy();
								MergePr.Merge(NewRPr);
								NewRPr = CheckWordRunPr(MergePr);
								if (!NewRPr) {
									NewRPr = MergePr;
								}
							}
							oItem.Set_Pr(NewRPr);
						} else {
							if (oTextPr) {
								MergePr = oTextPr.Copy();
								MergePr.Merge(oItem.Pr);
								NewRPr = CheckWordRunPr(MergePr);
								if (!NewRPr) {
									NewRPr = MergePr;
								}
								oItem.Set_Pr(NewRPr);
							}
						}
						break;
					}
					case para_Hyperlink: {
						CheckWordParagraphContent(oItem.Content);
						break;
					}
					case para_Math: {
						if (oItem.Root && oItem.Root.Content) {
							CheckWordParagraphContent(oItem.Root.Content);
						}
						break;
					}
					case para_Math_Run: {
						NewRPr = CheckWordRunPr(oItem.Pr, true);
						if (NewRPr) {
							MergePr = NewRPr;
							if (oTextPr) {
								MergePr = oTextPr.Copy();
								MergePr.Merge(NewRPr);
								NewRPr = CheckWordRunPr(MergePr);
								if (!NewRPr) {
									NewRPr = MergePr;
								}
							}
							oItem.Set_Pr(NewRPr);
						} else {
							if (oTextPr) {
								MergePr = oTextPr.Copy();
								MergePr.Merge(oItem.Pr);
								NewRPr = CheckWordRunPr(MergePr);
								if (!NewRPr) {
									NewRPr = MergePr;
								}
								oItem.Set_Pr(NewRPr);
							}
						}
						break;
					}
				}

			}
		}

		function ConvertGraphicFrameToWordTable(oGraphicFrame, oDocument) {
			oGraphicFrame.setWordFlag(false, oDocument);
			return oGraphicFrame.graphicObject.Copy(oDocument);
		}

		function ConvertTableToGraphicFrame(oTable, oPresentation) {
			var oGraphicFrame = new AscFormat.CGraphicFrame();
			var oTable2 = new CTable(oPresentation.DrawingDocument, oGraphicFrame, false, 0, [].concat(oTable.TableGrid), oTable.TableGrid.length, true);
			oTable2.Reset(0, 0, 50, 100000, 0, 0, 1);
			oTable2.SetTableLayout(tbllayout_Fixed);
			oTable2.Set_Pr(oTable.Pr.Copy());
			oTable2.Set_TableLook(oTable.TableLook.Copy());
			for (var i = 0; i < oTable.Content.length; ++i) {
				var oRow = oTable.Content[i];
				var oNewRow = new CTableRow(oTable2, oRow.Content.length, oTable2.TableGrid);
				for (var j = 0; j < oRow.Content.length; ++j) {
					var oContent = oRow.Content[j].Content;
					var oNewContent = oNewRow.Content[j].Content;
					for (var t = 0; t < oContent.Content.length; ++t) {
						if (oContent.Content[t].Get_Type() === type_Paragraph) {
							oNewContent.Internal_Content_Add(oNewContent.Content.length, AscFormat.ConvertParagraphToPPTX(oContent.Content[t], oPresentation.DrawingDocument, oNewContent));
						}
					}
				}
				var nIndex = oTable2.Content.length;
				oTable2.Content[nIndex] = oNewRow;
				AscCommon.History.Add(new CChangesTableAddRow(oTable2, nIndex, [oNewRow]));
				oTable2.private_UpdateTableGrid();
			}

			if (!oGraphicFrame.spPr) {
				oGraphicFrame.setSpPr(new AscFormat.CSpPr());
				oGraphicFrame.spPr.setParent(oGraphicFrame);
			}
			oGraphicFrame.spPr.setXfrm(new AscFormat.CXfrm());
			oGraphicFrame.spPr.xfrm.setExtX(50);
			oGraphicFrame.spPr.xfrm.setExtY(50);
			oGraphicFrame.spPr.xfrm.setParent(oGraphicFrame.spPr);
			var _nvGraphicFramePr = new AscFormat.UniNvPr();
			oGraphicFrame.setNvSpPr(_nvGraphicFramePr);
			if (AscCommon.isRealObject(_nvGraphicFramePr) && AscFormat.isRealNumber(_nvGraphicFramePr.locks)) {
				oGraphicFrame.setLocks(_nvGraphicFramePr.locks);
			}
			oGraphicFrame.setGraphicObject(oTable2);
			oGraphicFrame.setBDeleted(false);
			return oGraphicFrame;
		}


		function fHandleContent(aContent, oMax) {
			for (var i = 0; i < aContent.length; ++i) {
				var oContentElement = aContent[i];
				if (oContentElement.Get_Type() === type_Paragraph) {
					var paragraph_lines = aContent[i].Lines;
					let dIndRight = oContentElement.Get_CompiledPr().ParaPr.Ind.Right;
					for (var j = 0; j < paragraph_lines.length; ++j) {
						if (paragraph_lines[j].Ranges[0].W > oMax.max_width)
							oMax.max_width = paragraph_lines[j].Ranges[0].X + paragraph_lines[j].Ranges[0].W + dIndRight;
					}
				} else if (oContentElement.Get_Type() === type_Table) {
					if (oContentElement.Bounds.Right > oMax.max_width) {
						oMax.max_width = oContentElement.Bounds.Right;
					}
				} else if (oContentElement.Get_Type() === type_BlockLevelSdt) {
					if (oContentElement && oContentElement.Content) {
						fHandleContent(oContentElement.Content.Content, oMax);
					}
				}
			}
		}

		function RecalculateDocContentByMaxLine(oDocContent, dMaxWidth, bNeedRecalcAllDrawings) {
			var oMaxWidth = {max_width: 0}, i;
			oDocContent.Reset(0, 0, dMaxWidth, 20000);
			if (bNeedRecalcAllDrawings) {
				var aAllDrawings = oDocContent.GetAllDrawingObjects();
				for (i = 0; i < aAllDrawings.length; ++i) {
					aAllDrawings[i].GraphicObj.recalculate();
				}
			}
			let aTables = oDocContent.GetAllTables();
			for(let nIdx = 0; nIdx < aTables.length; ++nIdx) {
				let oTable = aTables[nIdx];
				oTable.RecalcInfo.Recalc_AllCells();
			}
			oDocContent.Recalculate_Page(0, true);
			fHandleContent(oDocContent.Content, oMaxWidth);
			if (oMaxWidth.max_width === 0) {
				if (oDocContent.Is_Empty()) {
					if (oDocContent.Content[0] && oDocContent.Content[0].Content[0] && oDocContent.Content[0].Content[0].Content[0]) {
						return oDocContent.Content[0].Content[0].Content[0].GetWidthVisible();
					}
				}
				return 0.001;
			}
			return oMaxWidth.max_width;
		}


		function CheckExcelDrawingXfrm(xfrm) {
			var rot = AscFormat.isRealNumber(xfrm.rot) ? xfrm.rot : 0;

			if (checkNormalRotate(rot)) {
				if (xfrm.offX < 0) {
					xfrm.setOffX(0);
				}
				if (xfrm.offY < 0) {
					xfrm.setOffY(0);
				}
			} else {
				var dPosX = xfrm.offX + xfrm.extX / 2 - xfrm.extY / 2;
				var dPosY = xfrm.offY + xfrm.extY / 2 - xfrm.extX / 2;
				if (dPosX < 0) {
					xfrm.setOffX(xfrm.offX - dPosX);
				}
				if (dPosY < 0) {
					xfrm.setOffY(xfrm.offY - dPosY);
				}
			}
		}


		function SetXfrmFromMetrics(oDrawing, metrics) {
			AscFormat.CheckSpPrXfrm(oDrawing);
			var rot = AscFormat.isRealNumber(oDrawing.spPr.xfrm.rot) ? AscFormat.normalizeRotate(oDrawing.spPr.xfrm.rot) : 0;

			var metricExtX, metricExtY;
			if (oDrawing.getObjectType() !== AscDFH.historyitem_type_GroupShape) {
				metricExtX = metrics.extX;
				metricExtY = metrics.extY;
				if (checkNormalRotate(rot)) {
					oDrawing.spPr.xfrm.setExtX(metrics.extX);
					oDrawing.spPr.xfrm.setExtY(metrics.extY);
				} else {
					oDrawing.spPr.xfrm.setExtX(metrics.extY);
					oDrawing.spPr.xfrm.setExtY(metrics.extX);
				}
			} else {
				if (AscFormat.isRealNumber(oDrawing.spPr.xfrm.extX) && AscFormat.isRealNumber(oDrawing.spPr.xfrm.extY)) {
					metricExtX = oDrawing.spPr.xfrm.extX;
					metricExtY = oDrawing.spPr.xfrm.extY;
				} else {
					metricExtX = metrics.extX;
					metricExtY = metrics.extY;
				}
			}

			if (checkNormalRotate(rot)) {
				oDrawing.spPr.xfrm.setOffX(metrics.x);
				oDrawing.spPr.xfrm.setOffY(metrics.y);
			} else {
				oDrawing.spPr.xfrm.setOffX(metrics.x + metricExtX / 2 - metricExtY / 2);
				oDrawing.spPr.xfrm.setOffY(metrics.y + metricExtY / 2 - metricExtX / 2);
			}
		}


		AscDFH.changesFactory[AscDFH.historyitem_ShapeSetNvSpPr] = AscDFH.CChangesDrawingsObject;
		AscDFH.changesFactory[AscDFH.historyitem_ShapeSetSpPr] = AscDFH.CChangesDrawingsObject;
		AscDFH.changesFactory[AscDFH.historyitem_ShapeSetTxXfrm] = AscDFH.CChangesDrawingsObject;
		AscDFH.changesFactory[AscDFH.historyitem_ShapeSetStyle] = AscDFH.CChangesDrawingsObject;
		AscDFH.changesFactory[AscDFH.historyitem_ShapeSetTxBody] = AscDFH.CChangesDrawingsObject;
		AscDFH.changesFactory[AscDFH.historyitem_ShapeSetTextBoxContent] = AscDFH.CChangesDrawingsObject;
		AscDFH.changesFactory[AscDFH.historyitem_ShapeSetBodyPr] = AscDFH.CChangesDrawingsObjectNoId;
		AscDFH.changesFactory[AscDFH.historyitem_AutoShapes_SetBFromSerialize] = AscDFH.CChangesDrawingsBool;
		AscDFH.changesFactory[AscDFH.historyitem_ShapeSetParent] = AscDFH.CChangesDrawingsObject;
		AscDFH.changesFactory[AscDFH.historyitem_ShapeSetGroup] = AscDFH.CChangesDrawingsObject;
		AscDFH.changesFactory[AscDFH.historyitem_ShapeSetWordShape] = AscDFH.CChangesDrawingsBool;
		AscDFH.changesFactory[AscDFH.historyitem_ShapeSetModelId] = AscDFH.CChangesDrawingsString;
		AscDFH.changesFactory[AscDFH.historyitem_ShapeSetSignature] = AscDFH.CChangesDrawingsObjectNoId;


		AscDFH.drawingsChangesMap[AscDFH.historyitem_ShapeSetNvSpPr] = function (oClass, value) {
			oClass.nvSpPr = value;
		};
		AscDFH.drawingsChangesMap[AscDFH.historyitem_ShapeSetTxXfrm] = function (oClass, value) {
			oClass.txXfrm = value;
		};
		AscDFH.drawingsChangesMap[AscDFH.historyitem_ShapeSetModelId] = function (oClass, value) {
			oClass.modelId = value;
		};
		AscDFH.drawingsChangesMap[AscDFH.historyitem_ShapeSetSpPr] = function (oClass, value) {
			oClass.spPr = value;
		};
		AscDFH.drawingsChangesMap[AscDFH.historyitem_ShapeSetStyle] = function (oClass, value) {
			oClass.style = value;
		};
		AscDFH.drawingsChangesMap[AscDFH.historyitem_ShapeSetTxBody] = function (oClass, value) {
			oClass.txBody = value;
		};
		AscDFH.drawingsChangesMap[AscDFH.historyitem_ShapeSetTextBoxContent] = function (oClass, value) {
			oClass.textBoxContent = value;
		};
		AscDFH.drawingsChangesMap[AscDFH.historyitem_ShapeSetBodyPr] = function (oClass, value) {
			oClass.bodyPr = value;
		};
		AscDFH.drawingsChangesMap[AscDFH.historyitem_AutoShapes_SetBFromSerialize] = function (oClass, value) {
			oClass.fromSerialize = value;
		};
		AscDFH.drawingsChangesMap[AscDFH.historyitem_ShapeSetParent] = function (oClass, value) {
			oClass.oldParent = oClass.parent;
			oClass.parent = value;
		};
		AscDFH.drawingsChangesMap[AscDFH.historyitem_ShapeSetGroup] = function (oClass, value) {
			oClass.group = value;
		};
		AscDFH.drawingsChangesMap[AscDFH.historyitem_ShapeSetWordShape] = function (oClass, value) {
			oClass.bWordShape = value;
		};
		AscDFH.drawingsChangesMap[AscDFH.historyitem_ShapeSetSignature] = function (oClass, value) {
			var oldSignature = oClass.signatureLine;
			var newSignature = value;
			oClass.signatureLine = value;
			//interface updating
			if (!AscCommon.isFileBuild()) {
				var oApi = window["Asc"] && window["Asc"]["editor"] || editor;
				if (oApi) {
					if (oldSignature && oldSignature.id) {
						oApi.sendEvent("asc_onRemoveSignature", oldSignature.id);
					}
					if (newSignature && newSignature.id) {
						oApi.sendEvent("asc_onAddSignature", newSignature.id);
					}
				}
			}
		};

		function CSignatureLine() {
			this.id = null;
			this.signer = null;
			this.signer2 = null;
			this.email = null;
			this.showDate = null;
			this.instructions = null;
		}

		CSignatureLine.prototype.Write_ToBinary = function (writer) {
			AscFormat.writeString(writer, this.id);
			AscFormat.writeString(writer, this.signer);
			AscFormat.writeString(writer, this.signer2);
			AscFormat.writeString(writer, this.email);
			AscFormat.writeBool(writer, this.showDate);
			AscFormat.writeString(writer, this.instructions);
		};
		CSignatureLine.prototype.Read_FromBinary = function (reader) {
			this.id = AscFormat.readString(reader);
			this.signer = AscFormat.readString(reader);
			this.signer2 = AscFormat.readString(reader);
			this.email = AscFormat.readString(reader);
			this.showDate = AscFormat.readBool(reader);
			this.instructions = AscFormat.readString(reader);
		};
		CSignatureLine.prototype.copy = function () {
			var ret = new CSignatureLine();
			ret.id = AscCommon.CreateGUID();
			ret.signer = this.signer;
			ret.signer2 = this.signer2;
			ret.email = this.email;
			ret.showDate = this.showDate;
			ret.instructions = this.instructions;
			return ret;
		};
		CSignatureLine.prototype.copyWithId = function () {
			var sId = this.id;
			var oCopy = this.copy();
			oCopy.id = sId;
			return oCopy;
		};
		CSignatureLine.prototype.setProperties = function (oPr) {
			this.signer = oPr.asc_getSigner1();
			this.signer2 = oPr.asc_getSigner2();
			this.email = oPr.asc_getEmail();
			this.showDate = oPr.asc_getShowDate();
			this.instructions = oPr.asc_getInstructions();
		};

		AscDFH.drawingsConstructorsMap[AscDFH.historyitem_ShapeSetBodyPr] = AscFormat.CBodyPr;
		AscDFH.drawingsConstructorsMap[AscDFH.historyitem_ShapeSetSignature] = CSignatureLine;


		const TEXT_RECT_ERROR = 0.01;

		/**
		 * @extends CGraphicObjectBase
		 * @constructor
		 */
		function CShape() {
			AscFormat.CGraphicObjectBase.call(this);
			this.nvSpPr = null;
			this.style = null;
			this.txBody = null;
			this.bodyPr = null;
			this.textBoxContent = null;
			this.drawingBase = null;//DrawingBase в Excell'е
			this.bWordShape = null;//если этот флаг стоит в true то автофигура имеет формат как в редакторе документов
			this.bCheckAutoFitFlag = false;
			this.signatureLine = null;
			this.txXfrm = null;
			this.modelId = null;


			this.transformText = new CMatrix();
			this.invertTransformText = null;

			this.localTransformText = new CMatrix();
			this.worksheet = null;
			this.cachedImage = null;

			this.txWarpStruct = null;
			this.txWarpStructParamarks = null;

			this.txWarpStructNoTransform = null;
			this.txWarpStructParamarksNoTransform = null;

			this.tmpFontScale = undefined;
			this.tmpLnSpcReduction = undefined;
			this.shapeSmartArtInfo = null;
		}

		AscFormat.InitClass(CShape, AscFormat.CGraphicObjectBase, AscDFH.historyitem_type_Shape);
		CShape.prototype.setCustT = function (value) {
			var pointContent = this.getSmartArtPointContent();
			if (pointContent) {
				pointContent.forEach(function (node) {
					const point = node.point;
					if (point.prSet && point.prSet.custT !== value) {
						point.prSet.setCustT(value);
					}
				});
				this.applyCustTSettings();
			}
		}

		CShape.prototype.setShapeSmartArtInfo = function (pr) {
			this.shapeSmartArtInfo = pr;
			if (this.shapeSmartArtInfo) {
				this.shapeSmartArtInfo.setShape(this);
			}
		}
		CShape.prototype.isActiveBlipFillPlaceholder = function () {
			const shapePoint = this.getSmartArtShapePoint();
			if (shapePoint) {
				let isContentFill = false;
				const contentPoints = this.getSmartArtPointContent();
				if (contentPoints && contentPoints[0]) {
					const contentPoint = contentPoints[0].point;
					isContentFill = contentPoint.spPr && contentPoint.spPr.Fill;
				}
				return shapePoint.isBlipFillPlaceholder() && !(shapePoint.spPr && shapePoint.spPr.Fill) && !isContentFill;
			}
		}
		CShape.prototype.getSmartArtInfo = function () {
			return this.shapeSmartArtInfo;
		}

		CShape.prototype.GetAllDrawingObjects = function (DrawingObjects) {
			var oContent = this.getDocContent();
			if (oContent) {
				oContent.GetAllDrawingObjects(DrawingObjects);
			}
		};
		CShape.prototype.setSignature = function (oSignature) {
			AscCommon.History.Add(new AscDFH.CChangesDrawingsObjectNoId(this, AscDFH.historyitem_ShapeSetSignature, this.signatureLine, oSignature));
			this.signatureLine = oSignature;
		};
		CShape.prototype.setSignaturePr = function (oPr, sUrl) {
			if (!oPr || !this.signatureLine) {
				return;
			}
			var oCopy = this.signatureLine.copyWithId();
			oCopy.setProperties(oPr);
			this.setSignature(oCopy);
			if (sUrl) {
				if (this.spPr) {
					var oBlipFillUnifill = AscFormat.CreateBlipFillUniFillFromUrl(sUrl);
					this.spPr.setFill(oBlipFillUnifill);
				}
			}
		};

		CShape.prototype.convertToWord = function (document) {
			this.setBDeleted(true);
			this.convertFromSmartArt();
			var c = new CShape();
			c.setWordShape(true);
			c.setBDeleted(false);
			if (this.nvSpPr) {
				c.setNvSpPr(this.nvSpPr.createDuplicate());
			}
			if (this.spPr) {
				c.setSpPr(this.spPr.createDuplicate());
				if (!c.spPr.geometry) {
					c.spPr.setGeometry(AscFormat.CreateGeometry("rect"));
				}
				c.spPr.setParent(c);
			}
			if (this.style) {
				c.setStyle(this.style.createDuplicate());
			}
			if (this.txBody) {
				if (this.txBody.bodyPr) {
					c.setBodyPr(this.txBody.bodyPr.createDuplicate());
				}
				if (this.txBody.content) {
					var new_content = new CDocumentContent(c, document.DrawingDocument, 0, 0, 0, 20000, false, false, false);
					var paragraphs = this.txBody.content.Content;

					new_content.Internal_Content_RemoveAll();
					for (var i = 0; i < paragraphs.length; ++i) {
						var cur_par = paragraphs[i];
						var new_paragraph = ConvertParagraphToWord(cur_par, new_content);
						new_content.Internal_Content_Add(i, new_paragraph, false);
					}
					c.setTextBoxContent(new_content);
				}
			}
			if (this.signatureLine) {
				c.setSignature(this.signatureLine.copy());
			}
			c.removePlaceholder();
			return c;
		};

		CShape.prototype.convertToPPTX = function (drawingDocument, worksheet, bIsAddMath) {
			let c = new CShape();
			this._convertToPPTX(c, drawingDocument, worksheet, bIsAddMath);
			return c;
		};
		CShape.prototype.convertToPdf = function (drawingDocument, worksheet, bIsAddMath) {
			let c = new AscPDF.CPdfShape();
			this._convertToPPTX(c, drawingDocument, worksheet, bIsAddMath);
			return c;
		};
		CShape.prototype._convertToPPTX = function(c, drawingDocument, worksheet, bIsAddMath)
		{
			c.setWordShape(false);
			c.setBDeleted(false);
			c.setWorksheet(worksheet);
			if (this.nvSpPr) {
				c.setNvSpPr(this.nvSpPr.createDuplicate());
			}
			if (this.spPr) {
				c.setSpPr(this.spPr.createDuplicate());
				c.spPr.setParent(c);
			}
			if (this.style) {
				c.setStyle(this.style.createDuplicate());
			}
			if (this.textBoxContent) {
				let tx_body = new AscFormat.CTextBody();
				tx_body.setParent(c);
				if (this.bodyPr) {
					tx_body.setBodyPr(this.bodyPr.createDuplicate());
				}
				let new_content = new AscFormat.CDrawingDocContent(tx_body, drawingDocument, 0, 0, 0, 0, false, false, true);
				let aContent = this.textBoxContent.Content;
				let aNewParagraphs = [];
				for (let nIdx = 0; nIdx < aContent.length; ++nIdx) {
					let oCurElement = aContent[nIdx];
					if (oCurElement instanceof AscWord.Paragraph) {
						let oParagraph = ConvertParagraphToPPTX(oCurElement, drawingDocument, new_content, bIsAddMath);
						aNewParagraphs.push(oParagraph);
					}
				}
				if (aNewParagraphs.length > 0) {
					new_content.Internal_Content_RemoveAll();
					for (let nIdx = 0; nIdx < aNewParagraphs.length; ++nIdx) {
						let oParagraph = aNewParagraphs[nIdx];
						new_content.Internal_Content_Add(nIdx, oParagraph, false);
					}
				}
				tx_body.setContent(new_content);
				c.setTxBody(tx_body);
			}
			if (worksheet) {
				if (this.signatureLine) {
					c.setSignature(this.signatureLine.copy());
				}
			}
		};
		CShape.prototype.convertFromSmartArt = function (bForce) {
			if (AscFormat.SmartArt && !bForce) {
				return this;
			}
			var txXfrm = this.txXfrm;
			if (txXfrm) {
				if (AscFormat.isRealNumber(txXfrm.rot) && this.txBody) {
					var oCopyBodyPr;
					var rot2 = txXfrm.rot;
					while (rot2 < 0) {
						rot2 += 2 * Math.PI;
					}
					var nSquare = ((2.0 * rot2 / Math.PI + 0.5) >> 0);
					while (nSquare < 0) {
						nSquare += 4;
					}
					switch (nSquare) {
						case 0: {
							oCopyBodyPr = this.txBody.bodyPr ? this.txBody.bodyPr.createDuplicate() : new AscFormat.CBodyPr();
							oCopyBodyPr.rot = (rot2 / AscFormat.cToRad + 0.5) >> 0;
							this.txBody.setBodyPr(oCopyBodyPr);
							break;
						}
						case 1: {
							oCopyBodyPr = this.txBody.bodyPr ? this.txBody.bodyPr.createDuplicate() : new AscFormat.CBodyPr();
							oCopyBodyPr.vert = AscFormat.nVertTTvert;
							this.txBody.setBodyPr(oCopyBodyPr);
							break;
						}
						case 2: {
							oCopyBodyPr = this.txBody.bodyPr ? this.txBody.bodyPr.createDuplicate() : new AscFormat.CBodyPr();
							oCopyBodyPr.rot = (rot2 / AscFormat.cToRad + 0.5) >> 0;
							this.txBody.setBodyPr(oCopyBodyPr);
							break;
						}
						case 3: {
							oCopyBodyPr = this.txBody.bodyPr ? this.txBody.bodyPr.createDuplicate() : new AscFormat.CBodyPr();
							oCopyBodyPr.vert = AscFormat.nVertTTvert270;
							this.txBody.setBodyPr(oCopyBodyPr);
							break;
						}
					}
				}
				this.setTxXfrm(null);
			}
			return this;
		};
		CShape.prototype.handleAllContents = function (fCallback) {
			var content = this.getDocContent();
			if (content) {
				fCallback(content);
			}
		};


		CShape.prototype.isTextBox = function () {
			return this.getTxBox() === true;
		};

		CShape.prototype.documentGetAllFontNames = function (AllFonts) {
			//TODO
			var content = this.getDocContent();
			if (content) {
				content.Document_Get_AllFontNames(AllFonts);
			}
		};

		CShape.prototype.documentCreateFontMap = function (map) {
			var content = this.getDocContent();
			if (content) {
				content.Document_CreateFontMap(map);
			}
		};


		CShape.prototype.setNvSpPr = function (pr) {
			AscCommon.History.Add(new AscDFH.CChangesDrawingsObject(this, AscDFH.historyitem_ShapeSetNvSpPr, this.nvSpPr, pr));
			this.nvSpPr = pr;
		};

		CShape.prototype.setTxXfrm = function (pr) {
			AscCommon.History.Add(new AscDFH.CChangesDrawingsObject(this, AscDFH.historyitem_ShapeSetTxXfrm, this.txXfrm, pr));
			this.txXfrm = pr;
			if (this.txXfrm) {
				this.txXfrm.setParent(this);
			}
		};
		CShape.prototype.getModelId = function () {
			return this.modelId;
		};
		CShape.prototype.setModelId = function (pr) {
			AscCommon.History.Add(new AscDFH.CChangesDrawingsString(this, AscDFH.historyitem_ShapeSetModelId, this.modelId, pr));
			this.modelId = pr;
		};

		CShape.prototype.setSpPr = function (spPr) {
			AscCommon.History.Add(new AscDFH.CChangesDrawingsObject(this, AscDFH.historyitem_ShapeSetSpPr, this.spPr, spPr));
			this.spPr = spPr;
			if (spPr) {
				spPr.setParent(this);
			}
		};

		CShape.prototype.setStyle = function (style) {
			AscCommon.History.Add(new AscDFH.CChangesDrawingsObject(this, AscDFH.historyitem_ShapeSetStyle, this.style, style));
			this.style = style;
			var content = this.getDocContent();

			this.recalcInfo.recalculateShapeStyleForParagraph = true;
			this.recalcInfo.recalculateContent2 = true;
			if (this.recalcTextStyles)
				this.recalcTextStyles();
			if (content) {
				content.Recalc_AllParagraphs_CompiledPr();
			}
		};

		CShape.prototype.setTxBody = function (txBody) {
			AscCommon.History.Add(new AscDFH.CChangesDrawingsObject(this, AscDFH.historyitem_ShapeSetTxBody, this.txBody, txBody));
			this.txBody = txBody;
			if (txBody && txBody.parent !== this) {
				txBody.setParent(this);
			}
		};

		CShape.prototype.setTextBoxContent = function (textBoxContent) {
			AscCommon.History.Add(new AscDFH.CChangesDrawingsObject(this, AscDFH.historyitem_ShapeSetTextBoxContent, this.textBoxContent, textBoxContent));
			this.textBoxContent = textBoxContent;
		};

		CShape.prototype.setBodyPr = function (pr) {
			AscCommon.History.Add(new AscDFH.CChangesDrawingsObjectNoId(this, AscDFH.historyitem_ShapeSetBodyPr, this.bodyPr, pr));
			this.bodyPr = pr;
			this.recalcInfo.recalculateContent = true;
			this.recalcInfo.recalculateTransformText = true;
			this.addToRecalculate();
		};
		CShape.prototype.setUseBgFill = function (pr) {
			AscCommon.History.Add(new AscDFH.CChangesDrawingsBool(this, AscDFH.historyitem_ShapeSetUseBgFill, this.useBgFill, pr));
			this.useBgFill = pr;
		};

		CShape.prototype.createTextBodyOnEdit = function () {
			let txBody = this.createTextBody();
			if (Asc.editor.isPresentationEditor) {
				let firstParagraph = txBody.content.Content[0];
				firstParagraph.SetParagraphAlign(AscCommon.align_Center);
				let newBodyPr = txBody.bodyPr.createDuplicate();
				newBodyPr.setAnchor(AscFormat.VERTICAL_ANCHOR_TYPE_CENTER);
				txBody.setBodyPr(newBodyPr);
			}
		};

		CShape.prototype.createTextBody = function () {
			var tx_body = new AscFormat.CTextBody();
			tx_body.setParent(this);
			tx_body.setContent(new AscFormat.CDrawingDocContent(tx_body, this.getDrawingDocument(), 0, 0, 0, 20000, false, false, true));
			var oBodyPr = new AscFormat.CBodyPr();
			if (this.worksheet) {
				oBodyPr.vertOverflow = AscFormat.nVOTClip;
				oBodyPr.horzOverflow = AscFormat.nHOTClip;
			}

			tx_body.setBodyPr(oBodyPr);
			tx_body.content.Content[0].Set_DocumentIndex(0);
			tx_body.content.MoveCursorToStartPos(false);
			this.setTxBody(tx_body);
			return tx_body;
		};

		CShape.prototype.createTextBoxContent = function () {
			var body_pr = new AscFormat.CBodyPr();
			body_pr.setAnchor(1);
			this.setBodyPr(body_pr);
			this.setTextBoxContent(new CDocumentContent(this, this.getDrawingDocument(), 0, 0, 0, 20000, false, false));
			this.textBoxContent.SetParagraphAlign(AscCommon.align_Center);
			this.textBoxContent.MoveCursorToStartPos(false);
			this.textBoxContent.Content[0].Set_DocumentIndex(0);
		};

		CShape.prototype.checkContentDrawings = function()
		{
			const oDocContent = this.getDocContent();
			if(oDocContent)
			{
				const aDrawings = oDocContent.GetAllDrawingObjects([]);
				for(let nDrawing = 0; nDrawing < aDrawings.length; ++nDrawing)
				{
					aDrawings[nDrawing].GraphicObj.updateTransformMatrix();
				}
			}
		};

		CShape.prototype.paragraphAdd = function (paraItem, bRecalculate) {
			var content_to_add = this.getDocContent();
			if (!content_to_add) {
				if (this.canEditText()) {
					if (this.bWordShape) {
						this.createTextBoxContent();
					} else {
						this.createTextBodyOnEdit();
					}
					content_to_add = this.getDocContent();
				}
			}
			if (content_to_add) {
				content_to_add.AddToParagraph(paraItem, bRecalculate);
			}
		};

		CShape.prototype.applyTextFunction = function (docContentFunction, tableFunction, args) {
			var content_to_add = this.getDocContent();
			if (!content_to_add) {
				if (this.canEditText()) {

					if (this.bWordShape) {
						this.createTextBoxContent();
					} else {
						this.createTextBodyOnEdit();
					}
					content_to_add = this.getDocContent();
					content_to_add.MoveCursorToStartPos();
				}
			}
			if (content_to_add) {
				if (this.isForm && this.isForm() && !content_to_add.IsCursorInSpecialForm())
					return;

				docContentFunction.apply(content_to_add, args);
			}
			if (!editor || !editor.noCreatePoint || editor.exucuteHistory) {
				var fontSize = args[0] && args[0].Value && args[0].Value.FontSize;
				if (fontSize) {
					this.setCustT(true);
				}
				this.checkExtentsByDocContent();
			}
		};

		CShape.prototype.copyTextInfoFromShapeToPoint = function (paddings) {
			var txBody = this.txBody;
			var pointContent = this.getSmartArtPointContent();
			var options = {};
			if (txBody && pointContent && pointContent.length !== 0) {
				options.pointContentLength = pointContent.length;
				var pointsCopy;

				for (var i = 0; i < pointContent.length; i += 1) {
					var point = pointContent[i].point;

					if (point.prSet && point.prSet.custT) {
						options.custT = true;
					}
					var bodyPr = point.t && point.t.bodyPr;
					if (bodyPr) {
						if (typeof bodyPr.lIns === 'number') {
							options.lIns = true;
						}
						if (typeof bodyPr.rIns === 'number') {
							options.rIns = true;
						}
						if (typeof bodyPr.bIns === 'number') {
							options.bIns = true;
						}
						if (typeof bodyPr.tIns === 'number') {
							options.tIns = true;
						}
					}
				}
				if (paddings) {
					if (typeof paddings.Left === 'number') {
						options.lIns = true;
					}
					if (typeof paddings.Right === 'number') {
						options.rIns = true;
					}
					if (typeof paddings.Bottom === 'number') {
						options.bIns = true;
					}
					if (typeof paddings.Top === 'number') {
						options.tIns = true;
					}
				}
				pointsCopy = txBody.createDuplicateForSmartArt(options);
				pointContent.forEach(function (node, idx) {
					const point = node.point;
					point.setT(pointsCopy[idx])
				});
			}
		};

		CShape.prototype.clearContent = function () {
			var content = this.getDocContent();
			if (content) {
				content.SetApplyToAll(true);
				content.Remove(-1);
				content.AddToParagraph(new AscCommonWord.ParaTextPr({Lang: {Val: undefined}}), false);
				content.SetApplyToAll(false);
			}
		};
		CShape.prototype.clearLang = function () {
			var content = this.getDocContent();
			if (content) {
				content.SetApplyToAll(true);
				content.AddToParagraph(new AscCommonWord.ParaTextPr({Lang: {Val: undefined}}), false);
				content.SetApplyToAll(false);
			}
		};

		CShape.prototype.getDocContent = function () {
			if (this.txBody) {
				return this.txBody.content;
			} else if (this.textBoxContent) {
				return this.textBoxContent;
			}
			return null;
		};

		CShape.prototype.getCurrentDocContentInSmartArt = function () {
			var content;
			if (this.txBody) {
				if (this.isPlaceholderInSmartArt()) {
					content = this.txBody.content2;
				} else {
					content = this.txBody.content;
				}
			}
			return content;
		}

		CShape.prototype.getBodyPr = function () {
			return AscFormat.ExecuteNoHistory(function () {

				let ret;
				if (this.bWordShape) {
					ret = new AscFormat.CBodyPr();
					ret.setDefault();
					if (this.bodyPr)
						ret.merge(this.bodyPr);
				} else {
					if (this.txBody && this.txBody.bodyPr) {
						ret = this.txBody.getCompiledBodyPr();
					} else {
						ret = new AscFormat.CBodyPr();
						ret.setDefault();
					}
				}
				let dScale = this.getScaleCoefficient();
				ret.lIns *= dScale;
				ret.tIns *= dScale;
				ret.rIns *= dScale;
				ret.bIns *= dScale;
				return ret;
			}, this, []);
		};

		CShape.prototype.GetRevisionsChangeElement = function (SearchEngine) {
			var oContent = this.getDocContent();
			if (oContent) {
				oContent.GetRevisionsChangeElement(SearchEngine);
			}
		};

		CShape.prototype.Search = function (SearchEngine, Type) {
			if (this.textBoxContent) {
				var dd = this.getDrawingDocument();
				dd.StartSearchTransform(this.transformText);
				this.textBoxContent.Search(SearchEngine, Type);
				dd.EndSearchTransform();
			} else if (this.txBody && this.txBody.content) {
				//var dd = this.getDrawingDocument();
				//dd.StartSearchTransform(this.transformText);
				this.txBody.content.Search(SearchEngine, Type);
				//dd.EndSearchTransform();
			}
		};

		CShape.prototype.GetSearchElementId = function (bNext, bCurrent) {
			if (this.textBoxContent)
				return this.textBoxContent.GetSearchElementId(bNext, bCurrent);

			else if (this.txBody && this.txBody.content) {
				return this.txBody.content.GetSearchElementId(bNext, bCurrent);
			}

			return null;
		};

		CShape.prototype.FindNextFillingForm = function (isNext, isCurrent) {
			if (this.textBoxContent)
				return this.textBoxContent.FindNextFillingForm(isNext, isCurrent, isCurrent);
			else if (this.txBody && this.txBody.content)
				return this.txBody.content.FindNextFillingForm(isNext, isCurrent, isCurrent);

			return null;
		};

		CShape.prototype.documentUpdateRulersState = function () {
			var content = this.getDocContent();
			if (!content)
				return;
			var xc, yc;
			var l, t, r, b;
			var body_pr = this.getBodyPr();
			var l_ins, t_ins, r_ins, b_ins;
			if (typeof body_pr.lIns === "number")
				l_ins = body_pr.lIns;
			else
				l_ins = 2.54;

			if (typeof body_pr.tIns === "number")
				t_ins = body_pr.tIns;
			else
				t_ins = 1.27;

			if (typeof body_pr.rIns === "number")
				r_ins = body_pr.rIns;
			else
				r_ins = 2.54;

			if (typeof body_pr.bIns === "number")
				b_ins = body_pr.bIns;
			else
				b_ins = 1.27;

			var oRect;
			if (this.getTextRect) {
				oRect = this.getTextRect();
			} else {
				oRect = {
					l: 0,
					t: 0,
					r: this.extX,
					b: this.extY
				};
			}
			l = oRect.l + l_ins;
			t = oRect.t + t_ins;
			r = oRect.r - r_ins;
			b = oRect.b - b_ins;

			var x_lt, y_lt, x_rt, y_rt, x_rb, y_rb, x_lb, y_lb;
			var tr = this.transform;
			x_lt = tr.TransformPointX(l, t);
			y_lt = tr.TransformPointY(l, t);

			x_rb = tr.TransformPointX(r, b);
			y_rb = tr.TransformPointY(r, b);


			xc = (x_lt + x_rb) * 0.5;
			yc = (y_lt + y_rb) * 0.5;

			var hc = (r - l) * 0.5;
			var vc = (b - t) * 0.5;

			this.getDrawingDocument().Set_RulerState_Paragraph({L: xc - hc, T: yc - vc, R: xc + hc, B: yc + vc});
			content.Document_UpdateRulersState(AscFormat.isRealNumber(this.selectStartPage) ? this.selectStartPage : 0);
		};

		CShape.prototype.setParent = function (parent) {
			AscCommon.History.Add(new AscDFH.CChangesDrawingsObject(this, AscDFH.historyitem_ShapeSetParent, this.parent, parent));
			this.parent = parent;
		};

		CShape.prototype.setGroup = function (group) {
			AscCommon.History.Add(new AscDFH.CChangesDrawingsObject(this, AscDFH.historyitem_ShapeSetGroup, this.group, group));
			this.group = group;
		};

		CShape.prototype.getAllImages = function (images) {
			if (this.spPr && this.spPr.Fill && this.spPr.Fill.fill instanceof AscFormat.CBlipFill && typeof this.spPr.Fill.fill.RasterImageId === "string") {
				images[AscCommon.getFullImageSrc2(this.spPr.Fill.fill.RasterImageId)] = true;
			}
			const oContent = this.getDocContent && this.getDocContent();
			if (oContent) {
				oContent.getBulletImages(images);
			}
		};

		CShape.prototype.getAllFonts = function (fonts) {
			if (this.txBody) {
				this.txBody.content.Document_Get_AllFontNames(fonts);
				if (this.txBody && this.txBody.lstStyle) {
					this.txBody.lstStyle.Document_Get_AllFontNames(fonts);
				}
				delete fonts["+mj-lt"];
				delete fonts["+mn-lt"];
				delete fonts["+mj-ea"];
				delete fonts["+mn-ea"];
				delete fonts["+mj-cs"];
				delete fonts["+mn-cs"];
			}
		};

		CShape.prototype.canFill = function () {
			if (this.spPr && this.spPr.geometry) {
				return this.spPr.geometry.canFill();
			}
			return true;
		};


		CShape.prototype.getHierarchy = function (bIsSingleBody, info) {
			let hierarchy = [];
			if (this.parent) {
				if (this.isPlaceholder()) {
					var ph_type = this.getPlaceholderType();
					var ph_index = this.getPlaceholderIndex();
					var b_is_single_body;
					if (AscFormat.isRealBool(bIsSingleBody)) {
						b_is_single_body = bIsSingleBody;
					} else {
						b_is_single_body = this.getIsSingleBody && this.getIsSingleBody();
					}
					switch (this.parent.kind) {
						case AscFormat.TYPE_KIND.SLIDE: {
							let oLayout = this.parent.Layout;
							if(oLayout) {
								hierarchy.push(oLayout.getMatchingShape(ph_type, ph_index, b_is_single_body, info));
								let oMaster = oLayout.Master;
								if(oMaster) {
									hierarchy.push(oMaster.getMatchingShape(ph_type, ph_index, true));
								}
							}
							break;
						}

						case AscFormat.TYPE_KIND.LAYOUT: {
							let oMaster = this.parent.Master;
							if(oMaster) {
								hierarchy.push(oMaster.getMatchingShape(ph_type, ph_index, true));
							}
							break;
						}

						case AscFormat.TYPE_KIND.NOTES: {
							let oMaster = this.parent.Master;
							if(oMaster) {
								hierarchy.push(oMaster.getMatchingShape(ph_type, ph_index, true));
							}
							break;
						}
					}
				}
			}
			return hierarchy;
		};


		CShape.prototype.getPaddings = function () {
			var paddings = null;
			var shape = this;
			var body_pr;
			if (shape.txBody) {
				if (shape.txBody.compiledBodyPr) {
					body_pr = shape.txBody.compiledBodyPr;
				} else {
					body_pr = shape.txBody.getCompiledBodyPr();
				}
			} else if (shape.textBoxContent) {
				body_pr = shape.bodyPr;
			}
			if (body_pr) {
				paddings = new Asc.asc_CPaddings();
				if (typeof body_pr.lIns === "number")
					paddings.Left = body_pr.lIns;
				else
					paddings.Left = 2.54;

				if (typeof body_pr.tIns === "number")
					paddings.Top = body_pr.tIns;
				else
					paddings.Top = 1.27;

				if (typeof body_pr.rIns === "number")
					paddings.Right = body_pr.rIns;
				else
					paddings.Right = 2.54;

				if (typeof body_pr.bIns === "number")
					paddings.Bottom = body_pr.bIns;
				else
					paddings.Bottom = 1.27;
			}
			return paddings;
		};

		CShape.prototype.getCompiledFill = function () {
			if (this.recalcInfo.recalculateFill) {
				this.compiledFill = null;
				if (isRealObject(this.spPr) && isRealObject(this.spPr.Fill) && isRealObject(this.spPr.Fill.fill)) {
					if (this.spPr.Fill.fill instanceof AscFormat.CGradFill && this.spPr.Fill.fill.colors.length === 0) {
						var parent_objects = this.getParentObjects();
						var theme = parent_objects.theme;
						var fmt_scheme = theme.themeElements.fmtScheme;
						var fill_style_lst = fmt_scheme.fillStyleLst;
						for (var i = fill_style_lst.length - 1; i > -1; --i) {
							if (fill_style_lst[i] && fill_style_lst[i].fill instanceof AscFormat.CGradFill) {
								this.spPr.Fill = fill_style_lst[i].createDuplicate();
								break;
							}
						}
					}
					this.compiledFill = this.spPr.Fill.createDuplicate();
					if (this.compiledFill && this.compiledFill.fill && this.compiledFill.fill.type === c_oAscFill.FILL_TYPE_GRP) {
						if (this.group) {
							var group_compiled_fill = this.group.getCompiledFill();
							if (isRealObject(group_compiled_fill) && isRealObject(group_compiled_fill.fill)) {
								this.compiledFill = group_compiled_fill.createDuplicate();
							} else {
								this.compiledFill = null;
							}
						} else {
							this.compiledFill = null;
						}
					}
				} else if (isRealObject(this.group)) {
					var group_compiled_fill = this.group.getCompiledFill();
					if (isRealObject(group_compiled_fill) && isRealObject(group_compiled_fill.fill)) {
						this.compiledFill = group_compiled_fill.createDuplicate();
					} else {
						var hierarchy = this.getHierarchy();
						for (var i = 0; i < hierarchy.length; ++i) {
							if (isRealObject(hierarchy[i]) && isRealObject(hierarchy[i].spPr) && isRealObject(hierarchy[i].spPr.Fill) && isRealObject(hierarchy[i].spPr.Fill.fill)) {
								this.compiledFill = hierarchy[i].spPr.Fill.createDuplicate();
								break;
							}
						}
					}
				} else {
					var hierarchy = this.getHierarchy();
					for (var i = 0; i < hierarchy.length; ++i) {
						if (isRealObject(hierarchy[i]) && isRealObject(hierarchy[i].spPr) && isRealObject(hierarchy[i].spPr.Fill) && isRealObject(hierarchy[i].spPr.Fill.fill)) {
							this.compiledFill = hierarchy[i].spPr.Fill.createDuplicate();
							break;
						}
					}
				}
				this.recalcInfo.recalculateFill = false;
			}
			return this.compiledFill;
		};

        CShape.prototype.getBounds = function () {
            return this.bounds;
        };

		CShape.prototype.getMargins = function () {
			if (this.txBody) {
				return this.txBody.getMargins()
			} else {
				return null;
			}
		};
		CShape.prototype.Document_UpdateRulersState = function (margins) {
			if (this.txBody && this.txBody.content) {
				this.txBody.content.Document_UpdateRulersState(this.getParentNum(), this.getMargins());
			}
		};

		CShape.prototype.getCompiledLine = function () {
			if (this.recalcInfo.recalculateLine) {
				this.compiledLine = null;
				if (isRealObject(this.spPr) && isRealObject(this.spPr.ln) && isRealObject(this.spPr.ln)) {
					this.compiledLine = this.spPr.ln.createDuplicate();
				} else if (isRealObject(this.group)) {
					var group_compiled_line = this.group.getCompiledLine();
					if (isRealObject(group_compiled_line) && isRealObject(group_compiled_line.fill)) {
						this.compiledLine = group_compiled_line.createDuplicate();
					} else {
						var hierarchy = this.getHierarchy();
						for (var i = 0; i < hierarchy.length; ++i) {
							if (isRealObject(hierarchy[i]) && isRealObject(hierarchy[i].spPr) && isRealObject(hierarchy[i].spPr.ln)) {
								this.compiledLine = hierarchy[i].spPr.ln.createDuplicate();
								break;
							}
						}
					}
				} else {
					var hierarchy = this.getHierarchy();
					for (var i = 0; i < hierarchy.length; ++i) {
						if (isRealObject(hierarchy[i]) && isRealObject(hierarchy[i].spPr) && isRealObject(hierarchy[i].spPr.ln)) {
							this.compiledLine = hierarchy[i].spPr.ln.createDuplicate();
							break;
						}
					}
				}
				this.recalcInfo.recalculateLine = false;
			}
			return this.compiledLine;
		};

		CShape.prototype.getCompiledTransparent = function () {
			if (this.recalcInfo.recalculateTransparent) {
				this.compiledTransparent = null;
				if (isRealObject(this.spPr) && isRealObject(this.spPr.Fill)) {
					if (AscFormat.isRealNumber(this.spPr.Fill.transparent)) {
						this.compiledTransparent = this.spPr.Fill.transparent;
					} else {
						if (this.spPr.Fill && this.spPr.Fill.fill && this.spPr.Fill.fill.type === c_oAscFill.FILL_TYPE_GRP) {
							if (this.group && this.group.spPr && this.group.spPr.Fill && AscFormat.isRealNumber(this.group.spPr.Fill.transparent)) {
								this.compiledTransparent = this.group.spPr.Fill.transparent;
							}
						}
					}

				}
				if (null !== this.compiledTransparent) {

					this.recalcInfo.recalculateTransparent = false;
					return this.compiledTransparent;
				}
				if (isRealObject(this.group)) {
					var group_transparent = this.group.getCompiledTransparent();
					if (AscFormat.isRealNumber(group_transparent)) {
						this.compiledTransparent = group_transparent;
					} else {
						var hierarchy = this.getHierarchy();
						for (var i = 0; i < hierarchy.length; ++i) {
							if (isRealObject(hierarchy[i]) && isRealObject(hierarchy[i].spPr) && isRealObject(hierarchy[i].spPr.Fill) && AscFormat.isRealNumber(hierarchy[i].spPr.Fill.transparent)) {
								this.compiledTransparent = hierarchy[i].spPr.Fill.transparent;
								break;
							}

						}
					}
				} else {
					var hierarchy = this.getHierarchy();
					for (var i = 0; i < hierarchy.length; ++i) {
						if (isRealObject(hierarchy[i]) && isRealObject(hierarchy[i].spPr) && isRealObject(hierarchy[i].spPr.Fill) && AscFormat.isRealNumber(hierarchy[i].spPr.Fill.transparent)) {
							this.compiledTransparent = hierarchy[i].spPr.Fill.transparent;
							break;
						}

					}
				}
				this.recalcInfo.recalculateTransparent = false;
			}
			return this.compiledTransparent;
		};

		CShape.prototype.getPlaceholderType = function () {
			let point = this.getSmartArtShapePoint();
			if (point) {
				return AscFormat.phType_pic;
			}
			return this.superclass.prototype.getPlaceholderType.call(this);
		};


		CShape.prototype.setVerticalAlign = function (align) {
			var content_to_add = this.getDocContent();
			if (!content_to_add) {
				if (this.canEditText()) {
					if (this.bWordShape) {
						this.createTextBoxContent();
					} else {
						this.createTextBodyOnEdit();
					}
				}
			}
			var new_body_pr = this.getBodyPr();
			if (new_body_pr) {
				new_body_pr = new_body_pr.createDuplicate();
				new_body_pr.anchor = align;
				if (this.bWordShape) {
					this.setBodyPr(new_body_pr);
				} else {
					if (this.txBody) {
						this.txBody.setBodyPr(new_body_pr);
					}
				}
				if (this.isObjectInSmartArt()) {
					this.copyTextInfoFromShapeToPoint();
				}
			}
		};
		CShape.prototype.setVert = function (vert) {
			var content_to_add = this.getDocContent();
			if (!content_to_add) {
				if (this.canEditText()) {
					if (this.bWordShape) {
						this.createTextBoxContent();
					} else {
						this.createTextBodyOnEdit();
					}
				}
			}
			var new_body_pr = this.getBodyPr();
			if (new_body_pr) {
				new_body_pr = new_body_pr.createDuplicate();
				new_body_pr.vert = vert;
				if (this.bWordShape) {
					this.setBodyPr(new_body_pr);
				} else {
					if (this.txBody) {
						this.txBody.setBodyPr(new_body_pr);
					}
				}
			}
			this.checkExtentsByDocContent && this.checkExtentsByDocContent();
		};


		CShape.prototype.setTextFitType = function (type) {
			if (AscFormat.isRealNumber(type)) {
				var new_body_pr = this.getBodyPr();
				if (new_body_pr) {
					new_body_pr = new_body_pr.createDuplicate();
					new_body_pr.textFit = new AscFormat.CTextFit();
					new_body_pr.textFit.type = type;

					if (this.bWordShape) {
						this.setBodyPr(new_body_pr);
					} else {
						if (this.txBody) {
							this.txBody.setBodyPr(new_body_pr);
						}
					}
				}
				this.checkExtentsByDocContent(true, true);
			}
		};


		CShape.prototype.setVertOverflowType = function (type) {
			if (AscFormat.isRealNumber(type)) {
				var new_body_pr = this.getBodyPr();
				if (new_body_pr) {
					new_body_pr = new_body_pr.createDuplicate();
					new_body_pr.vertOverflow = type;

					if (this.bWordShape) {
						this.setBodyPr(new_body_pr);
					} else {
						if (this.txBody) {
							this.txBody.setBodyPr(new_body_pr);
						}
					}
				}
				this.checkExtentsByDocContent(true, true);
			}
		};


		CShape.prototype.setPaddings = function (paddings, props) {
			props = props || {};
			if (paddings) {
				var new_body_pr = this.getBodyPr();
				if (new_body_pr) {
					new_body_pr = new_body_pr.createDuplicate();
					if (AscFormat.isRealNumber(paddings.Left)) {
						new_body_pr.lIns = paddings.Left;
					}

					if (AscFormat.isRealNumber(paddings.Top)) {
						new_body_pr.tIns = paddings.Top;
					}

					if (AscFormat.isRealNumber(paddings.Right)) {
						new_body_pr.rIns = paddings.Right;
					}
					if (AscFormat.isRealNumber(paddings.Bottom)) {
						new_body_pr.bIns = paddings.Bottom;
					}

					if (this.bWordShape) {
						this.setBodyPr(new_body_pr);
					} else {
						if (this.txBody) {
							this.txBody.setBodyPr(new_body_pr);
						}
					}
					if (this.isObjectInSmartArt() && !props.bNotCopyToPoints) {
						this.copyTextInfoFromShapeToPoint(paddings);
					}
				}
			}
		};

		CShape.prototype.recalculateTransformText = function () {

			var oContent = this.getDocContent();
			if (!oContent)
				return;

			var oBodyPr = this.getBodyPr();
			this.clipRect = this.checkTransformTextMatrix(this.localTransformText, oContent, oBodyPr, false);
			if (this.isForm && this.isForm()) {
				this.clipRect = {x: 0, y: -0.2, w: this.extX, h: this.extY + 0.4};
			}
			this.transformText = this.localTransformText.CreateDublicate();
			this.invertTransformText = global_MatrixTransformer.Invert(this.transformText);

			if (this.txBody && this.txBody.content2) {
				this.transformText2 = new CMatrix();
				this.clipRect2 = this.checkTransformTextMatrix(this.transformText2, this.txBody.content2, oBodyPr, false);
				this.invertTransformText2 = global_MatrixTransformer.Invert(this.transformText2);
				this.localTransformText2 = this.transformText2.CreateDublicate();
			}
			//if (oBodyPr.prstTxWarp) {
			var bNoTextNoShape = oBodyPr.prstTxWarp && oBodyPr.prstTxWarp.preset !== "textNoShape";
			/*if (this.bWordShape) {
            this.transformTextWordArt = this.transformText;
            this.invertTransformTextWordArt = this.invertTransformText;
        }
        else*/
			{
				this.localTransformTextWordArt = new CMatrix();
				this.checkTransformTextMatrix(this.localTransformTextWordArt, oContent, oBodyPr, bNoTextNoShape, !this.bWordShape && bNoTextNoShape);
				this.transformTextWordArt = this.localTransformTextWordArt.CreateDublicate();
				this.invertTransformTextWordArt = global_MatrixTransformer.Invert(this.transformTextWordArt);
			}
			if (this.txBody && this.txBody.content2) {
				this.checkTransformTextMatrix(this.transformText2, this.txBody.content2, oBodyPr, bNoTextNoShape, !this.bWordShape && bNoTextNoShape);
				this.transformTextWordArt2 = new CMatrix();
				this.checkTransformTextMatrix(this.transformTextWordArt2, this.txBody.content2, oBodyPr, bNoTextNoShape, !this.bWordShape && bNoTextNoShape);
			}
			// }

			if (this.checkPosTransformText) {
				this.checkPosTransformText();
			}
			if (this.checkContentDrawings) {
				this.checkContentDrawings();
			}
		};

		CShape.prototype.getFullFlip = function () {
			var _transform = this.localTransform;
			var _full_rotate = this.getFullRotate();
			var _full_pos_x_lt = _transform.TransformPointX(0, 0);
			var _full_pos_y_lt = _transform.TransformPointY(0, 0);

			var _full_pos_x_rt = _transform.TransformPointX(this.extX, 0);
			var _full_pos_y_rt = _transform.TransformPointY(this.extX, 0);

			var _full_pos_x_rb = _transform.TransformPointX(this.extX, this.extY);
			var _full_pos_y_rb = _transform.TransformPointY(this.extX, this.extY);

			var _rotate_matrix = new CMatrix();
			global_MatrixTransformer.RotateRadAppend(_rotate_matrix, _full_rotate);

			var _rotated_pos_x_lt = _rotate_matrix.TransformPointX(_full_pos_x_lt, _full_pos_y_lt);

			var _rotated_pos_x_rt = _rotate_matrix.TransformPointX(_full_pos_x_rt, _full_pos_y_rt);
			var _rotated_pos_y_rt = _rotate_matrix.TransformPointY(_full_pos_x_rt, _full_pos_y_rt);

			var _rotated_pos_y_rb = _rotate_matrix.TransformPointY(_full_pos_x_rb, _full_pos_y_rb);
			return {
				flipH: _rotated_pos_x_lt > _rotated_pos_x_rt,
				flipV: _rotated_pos_y_rt > _rotated_pos_y_rb
			};
		};

		CShape.prototype.getTextRect = function () {
			let oRect;
			if (this.txXfrm && this.spPr && this.spPr.xfrm) {
				var newL = this.txXfrm.offX - this.spPr.xfrm.offX;
				var newT = this.txXfrm.offY - this.spPr.xfrm.offY;
				var newR = newL + this.txXfrm.extX;
				var newB = newT + this.txXfrm.extY;
				oRect = {};
				let dScale = this.getScaleCoefficient();
				oRect.l = newL * dScale;
				oRect.t = newT * dScale;
				oRect.r = newR * dScale;
				oRect.b = newB * dScale;
			} else {
				let _r = this.spPr && this.spPr.geometry && this.spPr.geometry.rect;
				if (_r) {
					oRect = {
						l: _r.l,
						t: _r.t,
						r: _r.r,
						b: _r.b
					};
				}
			}
			if (oRect) {
				return oRect;
			}
			return {
				l: 0,
				t: 0,
				r: this.extX,
				b: this.extY
			};
		};
		CShape.prototype.checkTransformTextMatrixSmartArt = function (oMatrix, oContent, oBodyPr, bWordArtTransform, bIgnoreInsets) {
			if (this.txXfrm && (this.isObjectInSmartArt && this.isObjectInSmartArt())) {
				var oSmartArt = this.group.group;
				const bForceSlideTransform = oSmartArt.bForceSlideTransform;
				var diffX = 0;
				var diffY = 0;
				if (oSmartArt.group) {
					if (bForceSlideTransform || (AscFormat.isSlideLikeObject(this.parent) || this.worksheet) || Asc.editor.isPdfEditor()) {
						const oMainGroupRelativePosition = oSmartArt.group.getRelativePosition();
						diffX = oMainGroupRelativePosition.x;
						diffY = oMainGroupRelativePosition.y;
					} else {
						const oMainGroup = oSmartArt.getMainGroup();
						const oMainGroupRelativePosition = oSmartArt.getRelativePosition();
						diffX = oMainGroupRelativePosition.x - oMainGroup.x;
						diffY = oMainGroupRelativePosition.y - oMainGroup.y;
					}
				}
				var oRect = this.getTextRect();
				var oRectShape = new AscFormat.CShape();
				oRectShape.setBDeleted(false);
				oRectShape.setSpPr(new AscFormat.CSpPr());
				oRectShape.spPr.setParent(oRectShape);
				oRectShape.spPr.setXfrm(new AscFormat.CXfrm());
				oRectShape.spPr.xfrm.setParent(oRectShape.spPr);

				var defaultRot = this.getDefaultRotSA();
				var deltaRot = AscFormat.normalizeRotate(this.rot - defaultRot);
				var deltaShape = new AscFormat.CShape();
				deltaShape.setBDeleted(false);
				deltaShape.setSpPr(new AscFormat.CSpPr());
				deltaShape.spPr.setParent(deltaShape);
				deltaShape.spPr.setXfrm(new AscFormat.CXfrm());
				deltaShape.spPr.xfrm.setParent(deltaShape.spPr);
				deltaShape.spPr.xfrm.setOffX(this.spPr.xfrm.offX - diffX);
				deltaShape.spPr.xfrm.setOffY(this.spPr.xfrm.offY - diffY);
				deltaShape.spPr.xfrm.setExtX(this.spPr.xfrm.extX);
				deltaShape.spPr.xfrm.setExtY(this.spPr.xfrm.extY);
				if (deltaRot) {
					deltaShape.spPr.xfrm.setRot(deltaRot);
				}
				deltaShape.setGroup(this.group);
				deltaShape.parent = this.parent;
				// deltaShape.changeFlipH(this.spPr.xfrm.flipH); TODO: repair this
				// deltaShape.changeFlipV(this.spPr.xfrm.flipV);
				deltaShape.recalculateLocalTransform(deltaShape.localTransform);

				var extX = (oRect.r - oRect.l) / 2;
				var extY = (oRect.b - oRect.t) / 2;
				var deltaTranslateX = 0, deltaTranslateY = 0;
				if (bForceSlideTransform || (AscFormat.isSlideLikeObject(deltaShape.parent) || this.worksheet) || Asc.editor.isPdfEditor()) {
					deltaTranslateX = deltaShape.group.group.x;
					deltaTranslateY = deltaShape.group.group.y;
				}
				var xc = deltaShape.localTransform.TransformPointX(oRect.l + extX, oRect.t + extY) - deltaTranslateX;
				var yc = deltaShape.localTransform.TransformPointY(oRect.l + extX, oRect.t + extY) - deltaTranslateY;

				let dScale = this.getScaleCoefficient();
				oRectShape.spPr.xfrm.setOffX((xc - extX) / dScale);
				oRectShape.spPr.xfrm.setOffY((yc - extY) / dScale);
				oRectShape.spPr.xfrm.setExtX(this.txXfrm.extX);
				oRectShape.spPr.xfrm.setExtY(this.txXfrm.extY);
				// oRectShape.changeFlipH(this.spPr.xfrm.flipH); TODO: repair this
				// oRectShape.changeFlipV(this.spPr.xfrm.flipV);
				oRectShape.spPr.xfrm.setRot(AscFormat.normalizeRotate(this.txXfrm.rot + this.spPr.xfrm.rot));
				oRectShape.setGroup(this.group);
				oRectShape.parent = this.parent;
				oRectShape.recalculateLocalTransform(oRectShape.localTransform);
				return oRectShape.checkTransformTextMatrix(oMatrix, oContent, oBodyPr, bWordArtTransform, bIgnoreInsets);
			}
		}

		CShape.prototype.getFormRelRect = function (isUsePaddings) {
			var oSpTransform = this.transform;
			var oInvTextTransform = this.invertTransformText;

			var nX = 0, nW = this.extX;
			var nY = 0, nH = this.extY;

			if (isUsePaddings) {
				let nFormHorPadding = this.getFormHorPadding();
				nX += nFormHorPadding;
				nW -= 2 * nFormHorPadding;
			}

			var aX = [nX, nW];
			var aY = [nY, nH];
			var fX0, fY0;

			if (!oSpTransform || !oInvTextTransform) {
				return {
					X: nX,
					Y: nY,
					W: nW,
					H: nH,
					Page: this.parent.PageNum
				};
			}

			var aRelX = [], aRelY = [];
			for (var nX = 0; nX < aX.length; ++nX) {
				fX0 = aX[nX];
				for (var nY = 0; nY < aY.length; ++nY) {
					fY0 = aY[nY];
					var fX = oSpTransform.TransformPointX(fX0, fY0);
					var fY = oSpTransform.TransformPointY(fX0, fY0);
					var fRelX = oInvTextTransform.TransformPointX(fX, fY);
					var fRelY = oInvTextTransform.TransformPointY(fX, fY);
					aRelX.push(fRelX);
					aRelY.push(fRelY);
				}
			}

			return {
				X: Math.min.apply(Math, aRelX),
				Y: Math.min.apply(Math, aRelY),
				W: nW,
				H: nH,
				Page: this.parent.PageNum
			};
		};

		CShape.prototype.checkTransformTextMatrix = function (oMatrix, oContent, oBodyPr, bWordArtTransform, bIgnoreInsets) {
			oMatrix.Reset();
			let _shape_transform = this.localTransform;
			let _content_height = oContent.GetSummaryHeight();
			let _l, _t, _r, _b;
			let _t_x_lt, _t_y_lt, _t_x_rt, _t_y_rt, _t_x_lb, _t_y_lb, _t_x_rb, _t_y_rb;



			let oRect = this.getTextRect();
			if (this.txXfrm) {
				return this.checkTransformTextMatrixSmartArt(oMatrix, oContent, oBodyPr, bWordArtTransform, bIgnoreInsets);
			}
			let oInsets = this.getInsets({bIgnoreInsets: bIgnoreInsets, bodyPr: oBodyPr});
			let l_ins = oInsets.lIns;
			let t_ins = oInsets.tIns;
			let r_ins = oInsets.rIns;
			let b_ins = oInsets.bIns;

			_l = oRect.l + l_ins;
			_t = oRect.t + t_ins;
			_r = oRect.r - r_ins;
			_b = oRect.b - b_ins;

			if (_l >= _r) {
				var _c = (_l + _r) * 0.5;
				_l = _c - 0.01;
				_r = _c + 0.01;
			}

			if (_t >= _b) {
				_c = (_t + _b) * 0.5;
				_t = _c - 0.01;
				_b = _c + 0.01;
			}

			var XC = oContent.XLimit / 2.0;
			var YC = _content_height / 2.0;

			var _rot_angle = AscFormat.normalizeRotate((AscFormat.isRealNumber(oBodyPr.rot) ? oBodyPr.rot : 0) * AscFormat.cToRad);

			if (!AscFormat.fApproxEqual(_rot_angle, 0.0)) {
				global_MatrixTransformer.TranslateAppend(oMatrix, -XC, -YC);
				global_MatrixTransformer.RotateRadAppend(oMatrix, -_rot_angle);
				global_MatrixTransformer.TranslateAppend(oMatrix, XC, YC);
			}

			_t_x_lt = _shape_transform.TransformPointX(_l, _t);
			_t_y_lt = _shape_transform.TransformPointY(_l, _t);

			_t_x_rt = _shape_transform.TransformPointX(_r, _t);
			_t_y_rt = _shape_transform.TransformPointY(_r, _t);

			_t_x_lb = _shape_transform.TransformPointX(_l, _b);
			_t_y_lb = _shape_transform.TransformPointY(_l, _b);

			_t_x_rb = _shape_transform.TransformPointX(_r, _b);
			_t_y_rb = _shape_transform.TransformPointY(_r, _b);

			var _dx_t, _dy_t;
			_dx_t = _t_x_rt - _t_x_lt;
			_dy_t = _t_y_rt - _t_y_lt;

			var _dx_lt_rb, _dy_lt_rb;
			_dx_lt_rb = _t_x_rb - _t_x_lt;
			_dy_lt_rb = _t_y_rb - _t_y_lt;

			var _vertical_shift;
			var _text_rect_height = _b - _t;
			var _text_rect_width = _r - _l;
			var oClipRect;
			var Diff = 1.6;

			const oForm = this.isForm && this.isForm() ? this.getInnerForm() : null;
			if (oForm) {
				if (oForm.IsMultiLineForm())
					_vertical_shift = 0;
				else
					_vertical_shift = (_text_rect_height - _content_height) * 0.5;

				global_MatrixTransformer.TranslateAppend(oMatrix, 0, _vertical_shift);
				if (_dx_lt_rb * _dy_t - _dy_lt_rb * _dx_t <= 0) {
					var alpha = Math.atan2(_dy_t, _dx_t);
					global_MatrixTransformer.RotateRadAppend(oMatrix, -alpha);
					global_MatrixTransformer.TranslateAppend(oMatrix, _t_x_lt, _t_y_lt);
				} else {
					var alpha = Math.atan2(_dy_t, _dx_t);
					global_MatrixTransformer.RotateRadAppend(oMatrix, Math.PI - alpha);
					global_MatrixTransformer.TranslateAppend(oMatrix, _t_x_rt, _t_y_rt);
				}
			} else if (!oBodyPr.upright) {
				if (!(oBodyPr.vert === AscFormat.nVertTTvert || oBodyPr.vert === AscFormat.nVertTTvert270 || oBodyPr.vert === AscFormat.nVertTTeaVert)) {
					if (bWordArtTransform) {
						_vertical_shift = 0;
					} else {
						if ((!this.bWordShape && oBodyPr.vertOverflow === AscFormat.nVOTOverflow) || _content_height < _text_rect_height) {
							switch (oBodyPr.anchor) {
								case 0: //b
								{ // (Text Anchor Enum ( Bottom ))
									_vertical_shift = _text_rect_height - _content_height;

									break;
								}
								case 1:    //ctr
								case 2:    //dist TODO: пока выравнивание  по центру. Переделать!
								case 3:    //just TODO: пока выравнивание  по центру. Переделать!
									// (Text Anchor Enum ( Center ))
									_vertical_shift = (_text_rect_height - _content_height) * 0.5;
									break;

								// case 2: //dist
								// {// (Text Anchor Enum ( Distributed )) TODO: пока выравнивание  по центру. Переделать!
								//     _vertical_shift = (_text_rect_height - _content_height) * 0.5;
								//     break;
								// }
								// case 3: //just
								// {// (Text Anchor Enum ( Justified )) TODO: пока выравнивание  по центру. Переделать!
								//     _vertical_shift = (_text_rect_height - _content_height) * 0.5;
								//     break;
								// }
								case 4: //t
								{//Top
									_vertical_shift = 0;
									break;
								}
							}
						} else {


							if ((!this.bWordShape && oBodyPr.vertOverflow === AscFormat.nVOTClip)
								&& oContent.Content[0] && oContent.Content[0].Lines[0] && oContent.Content[0].Lines[0].Bottom > _text_rect_height) {
								var _content_first_line = oContent.Content[0].Lines[0].Bottom;
								switch (oBodyPr.anchor) {
									case 0: //b
									{ // (Text Anchor Enum ( Bottom ))
										_vertical_shift = _text_rect_height - _content_first_line;
										break;
									}
									case 1:    //ctr
									{// (Text Anchor Enum ( Center ))
										_vertical_shift = (_text_rect_height - _content_first_line) * 0.5;
										break;
									}
									case 2: //dist
									{// (Text Anchor Enum ( Distributed ))
										_vertical_shift = (_text_rect_height - _content_first_line) * 0.5;
										break;
									}
									case 3: //just
									{// (Text Anchor Enum ( Justified ))
										_vertical_shift = (_text_rect_height - _content_first_line) * 0.5;
										break;
									}
									case 4: //t
									{//Top
										_vertical_shift = 0;
										break;
									}
								}
							} else {
								if (this.bWordShape) {
									_vertical_shift = 0;
								} else {
									if (oBodyPr.anchor === 0) {
										_vertical_shift = _text_rect_height - _content_height;
									} else {
										_vertical_shift = 0;
									}
								}
							}

						}
					}
					global_MatrixTransformer.TranslateAppend(oMatrix, 0, _vertical_shift);
					if (_dx_lt_rb * _dy_t - _dy_lt_rb * _dx_t <= 0) {
						var alpha = Math.atan2(_dy_t, _dx_t);
						global_MatrixTransformer.RotateRadAppend(oMatrix, -alpha);
						global_MatrixTransformer.TranslateAppend(oMatrix, _t_x_lt, _t_y_lt);
					} else {
						alpha = Math.atan2(_dy_t, _dx_t);
						global_MatrixTransformer.RotateRadAppend(oMatrix, Math.PI - alpha);
						global_MatrixTransformer.TranslateAppend(oMatrix, _t_x_rt, _t_y_rt);
					}
				} else {
					if (bWordArtTransform) {
						_vertical_shift = 0;
					} else {
						if ((!this.bWordShape && oBodyPr.vertOverflow === AscFormat.nVOTOverflow) || _content_height <= _text_rect_width) {
							switch (oBodyPr.anchor) {
								case 0: //b
								{ // (Text Anchor Enum ( Bottom ))
									_vertical_shift = _text_rect_width - _content_height;
									break;
								}
								case 1:    //ctr
								{// (Text Anchor Enum ( Center ))
									_vertical_shift = (_text_rect_width - _content_height) * 0.5;
									break;
								}
								case 2: //dist
								{// (Text Anchor Enum ( Distributed ))
									_vertical_shift = (_text_rect_width - _content_height) * 0.5;
									break;
								}
								case 3: //just
								{// (Text Anchor Enum ( Justified ))
									_vertical_shift = (_text_rect_width - _content_height) * 0.5;
									break;
								}
								case 4: //t
								{//Top
									_vertical_shift = 0;
									break;
								}
							}
						} else {

							if (this.bWordShape) {
								_vertical_shift = 0;
							} else {
								if (oBodyPr.anchor === 0) {
									_vertical_shift = _text_rect_width - _content_height;
								} else {
									_vertical_shift = 0;
								}
							}
						}
					}
					global_MatrixTransformer.TranslateAppend(oMatrix, 0, _vertical_shift);
					var _alpha;
					_alpha = Math.atan2(_dy_t, _dx_t);
					if (oBodyPr.vert === AscFormat.nVertTTvert || oBodyPr.vert === AscFormat.nVertTTeaVert) {
						if (_dx_lt_rb * _dy_t - _dy_lt_rb * _dx_t <= 0) {
							global_MatrixTransformer.RotateRadAppend(oMatrix, -_alpha - Math.PI * 0.5);
							global_MatrixTransformer.TranslateAppend(oMatrix, _t_x_rt, _t_y_rt);
						} else {
							global_MatrixTransformer.RotateRadAppend(oMatrix, Math.PI * 0.5 - _alpha);
							global_MatrixTransformer.TranslateAppend(oMatrix, _t_x_lt, _t_y_lt);
						}
					} else {
						if (_dx_lt_rb * _dy_t - _dy_lt_rb * _dx_t <= 0) {
							global_MatrixTransformer.RotateRadAppend(oMatrix, -_alpha - Math.PI * 1.5);
							global_MatrixTransformer.TranslateAppend(oMatrix, _t_x_lb, _t_y_lb);
						} else {
							global_MatrixTransformer.RotateRadAppend(oMatrix, -Math.PI * 0.5 - _alpha);
							global_MatrixTransformer.TranslateAppend(oMatrix, _t_x_rb, _t_y_rb);
						}
					}
				}

				var rect = this.getTextRect && this.getTextRect();
				if (rect) {
					var clipW = rect.r - rect.l + Diff;
					if (clipW <= 0) {
						clipW = 0.01;
					}
					var clipH = rect.b - rect.t + Diff - b_ins - t_ins;
					if (clipH < 0) {
						clipH = 0.01;
					}
					oClipRect = {x: rect.l - Diff, y: rect.t - Diff + t_ins, w: clipW, h: clipH};
				} else {
					oClipRect = {x: -1.6, y: t_ins, w: this.extX + 3.2, h: this.extY - b_ins};
				}

			} else {
				var _full_rotate = this.getFullRotate();
				var _full_flip = this.getFullFlip();

				var _hc = this.extX * 0.5;
				var _vc = this.extY * 0.5;
				var _transformed_shape_xc = this.localTransform.TransformPointX(_hc, _vc);
				var _transformed_shape_yc = this.localTransform.TransformPointY(_hc, _vc);


				var _content_width, content_height2;
				if (checkNormalRotate(_full_rotate)) {
					if (!(oBodyPr.vert === AscFormat.nVertTTvert || oBodyPr.vert === AscFormat.nVertTTvert270 || oBodyPr.vert === AscFormat.nVertTTeaVert)) {
						_content_width = _r - _l;
						content_height2 = _b - _t;
					} else {
						_content_width = _b - _t;
						content_height2 = _r - _l;
					}
				} else {
					if (!(oBodyPr.vert === AscFormat.nVertTTvert || oBodyPr.vert === AscFormat.nVertTTvert270 || oBodyPr.vert === AscFormat.nVertTTeaVert)) {
						_content_width = _b - _t;
						content_height2 = _r - _l;

					} else {
						_content_width = _r - _l;
						content_height2 = _b - _t;
					}
				}

				if (bWordArtTransform) {
					_vertical_shift = 0;
				} else {
					if (!(this.bWordShape || this.worksheet) || _content_height < content_height2) {
						switch (oBodyPr.anchor) {
							case 0: //b
							{ // (Text Anchor Enum ( Bottom ))
								_vertical_shift = content_height2 - _content_height;
								break;
							}
							case 1:    //ctr
							{// (Text Anchor Enum ( Center ))
								_vertical_shift = (content_height2 - _content_height) * 0.5;
								break;
							}
							case 2: //dist
							{// (Text Anchor Enum ( Distributed ))
								_vertical_shift = (content_height2 - _content_height) * 0.5;
								break;
							}
							case 3: //just
							{// (Text Anchor Enum ( Justified ))
								_vertical_shift = (content_height2 - _content_height) * 0.5;
								break;
							}
							case 4: //t
							{//Top
								_vertical_shift = 0;
								break;
							}
						}
					} else {
						if (this.bWordShape) {
							_vertical_shift = 0;
						} else {
							if (oBodyPr.anchor === 0) {
								_vertical_shift = content_height2 - _content_height;
							} else {
								_vertical_shift = 0;
							}
						}
					}

				}

				var _text_rect_xc = _l + (_r - _l) * 0.5;
				var _text_rect_yc = _t + (_b - _t) * 0.5;

				var _vx = _text_rect_xc - _hc;
				var _vy = _text_rect_yc - _vc;

				var _transformed_text_xc, _transformed_text_yc;
				if (!_full_flip.flipH) {
					_transformed_text_xc = _transformed_shape_xc + _vx;
				} else {
					_transformed_text_xc = _transformed_shape_xc - _vx;
				}

				if (!_full_flip.flipV) {
					_transformed_text_yc = _transformed_shape_yc + _vy;
				} else {
					_transformed_text_yc = _transformed_shape_yc - _vy;
				}

				global_MatrixTransformer.TranslateAppend(oMatrix, 0, _vertical_shift);
				if (oBodyPr.vert === AscFormat.nVertTTvert || oBodyPr.vert === AscFormat.nVertTTeaVert) {
					global_MatrixTransformer.TranslateAppend(oMatrix, -_content_width * 0.5, -content_height2 * 0.5);
					global_MatrixTransformer.RotateRadAppend(oMatrix, -Math.PI * 0.5);
					global_MatrixTransformer.TranslateAppend(oMatrix, _content_width * 0.5, content_height2 * 0.5);

				}
				if (oBodyPr.vert === AscFormat.nVertTTvert270) {
					global_MatrixTransformer.TranslateAppend(oMatrix, -_content_width * 0.5, -content_height2 * 0.5);
					global_MatrixTransformer.RotateRadAppend(oMatrix, -Math.PI * 1.5);
					global_MatrixTransformer.TranslateAppend(oMatrix, _content_width * 0.5, content_height2 * 0.5);
				}
				global_MatrixTransformer.TranslateAppend(oMatrix, _transformed_text_xc - _content_width * 0.5, _transformed_text_yc - content_height2 * 0.5);

				if (this.bWordShape) {
					var DiffLeft = 0.01;
					var DiffRight = 0.01;
					var DiffLeft2, DiffRight2;
					var aContent = oContent.Content;
					for (var i = 0; i < aContent.length; ++i) {
						var oElement = aContent[i];
						if (!oElement.GetType) {
							continue;
						}
						var nElementType = oElement.GetType();
						if (nElementType === AscCommonWord.type_Paragraph) {
							var oCompiledParaPr = oElement.CompiledPr && oElement.CompiledPr.Pr && oElement.CompiledPr.Pr.ParaPr;
							if (oCompiledParaPr) {
								var oBorders = oCompiledParaPr.Brd;
								if (oBorders) {
									if (oBorders.Left && AscFormat.isRealNumber(oBorders.Left.Space) && AscFormat.isRealNumber(oBorders.Left.Size) && oBorders.Left.Size > 0.0) {
										DiffLeft2 = oBorders.Left.Space + oBorders.Left.Size;
										if (DiffLeft2 > DiffLeft) {
											DiffLeft = DiffLeft2;
										}
									}
									if (oBorders.Right && AscFormat.isRealNumber(oBorders.Right.Space) && AscFormat.isRealNumber(oBorders.Right.Size) && oBorders.Right.Size > 0.0) {
										DiffRight2 = oBorders.Right.Space + oBorders.Right.Size;
										if (oCompiledParaPr.Ind && AscFormat.isRealNumber(oCompiledParaPr.Ind.Right)) {
											DiffRight2 -= oCompiledParaPr.Ind.Right;
										}
										if (DiffRight2 > DiffRight) {
											DiffRight = DiffRight2;
										}
									}
								}
							}
						} else if (nElementType === AscCommonWord.type_Table) {
							DiffLeft2 = -oElement.GetTableOffsetCorrection();
							if (DiffLeft2 > DiffLeft) {
								DiffLeft = DiffLeft2;
							}
							DiffRight2 = oElement.GetRightTableOffsetCorrection();
							if (DiffRight2 > DiffRight) {
								DiffRight = DiffRight2;
							}
						} else if (nElementType === AscCommonWord.type_BlockLevelSdt) {

						}
					}


					var clipW = oRect.r - oRect.l + DiffLeft + DiffRight;
					if (clipW <= 0) {
						clipW = 0.01;
					}
					var clipH = oRect.b - oRect.t + Diff - b_ins - t_ins;
					if (clipH < 0) {
						clipH = 0.01;
					}
					oClipRect = {x: oRect.l - DiffLeft, y: oRect.t - Diff + t_ins, w: clipW, h: clipH};
				} else {
					var clipW = oRect.r - oRect.l + Diff - l_ins - r_ins;
					if (clipW <= 0) {
						clipW = 0.01;
					}
					var clipH = oRect.b - oRect.t + Diff - b_ins - t_ins;
					if (clipH < 0) {
						clipH = 0.01;
					}
					oClipRect = {x: oRect.l + l_ins - Diff, y: oRect.t - Diff + t_ins, w: clipW, h: clipH};

				}
			}
			return oClipRect;
		};

		CShape.prototype.setWordShape = function (pr) {
			AscCommon.History.Add(new AscDFH.CChangesDrawingsBool(this, AscDFH.historyitem_ShapeSetWordShape, this.bWordShape, pr));
			this.bWordShape = pr;
		};

		CShape.prototype.selectionCheck = function (X, Y, PageAbs, NearPos) {

			var content = this.getDocContent();
			if (content) {
				if (undefined !== NearPos)
					return content.CheckPosInSelection(X, Y, 0, NearPos);

				if (isRealObject(content) && this.hitInTextRect(X, Y) && this.invertTransformText) {
					var t_x = this.invertTransformText.TransformPointX(X, Y);
					var t_y = this.invertTransformText.TransformPointY(X, Y);
					return content.CheckPosInSelection(t_x, t_y, 0, NearPos);
				}
			}
			return false;
		};

		CShape.prototype.fillObject = function (copy, oPr) {
			if (this.nvSpPr)
				copy.setNvSpPr(this.nvSpPr.createDuplicate());
			if (this.spPr) {
				copy.setSpPr(this.spPr.createDuplicate());
				copy.spPr.setParent(copy);
			}
			if (this.style) {
				copy.setStyle(this.style.createDuplicate());
			}
			if (this.txBody) {
				copy.setTxBody(this.txBody.createDuplicate());
				copy.txBody.setParent(copy);
			}
			if (this.bodyPr) {
				copy.setBodyPr(this.bodyPr.createDuplicate());
			}
			if (this.textBoxContent) {
				const contentCopyPr = oPr && oPr.contentCopyPr;
				const fCallback = function () {
					copy.setTextBoxContent(this.textBoxContent.Copy(copy, oPr && oPr.drawingDocument, contentCopyPr));
				}.bind(this);
				if (contentCopyPr && contentCopyPr.Comparison && !contentCopyPr.Comparison.options.textBoxes) {
					contentCopyPr.Comparison.executeWithSkipCopiedElements(fCallback);
				} else {
					fCallback();
				}
			}
			if (this.signatureLine && copy.setSignature) {
				copy.setSignature(this.signatureLine.copy());
			}
			if (this.macro !== null) {
				copy.setMacro(this.macro);
			}
			if (this.textLink !== null) {
				copy.setTextLink(this.textLink);
			}
			if (this.clientData) {
				copy.setClientData(this.clientData.createDuplicate());
			}
			if (this.fLocksText !== null) {
				copy.setFLocksText(this.fLocksText);
			}
			copy.setWordShape(this.bWordShape);
			copy.setBDeleted(this.bDeleted);
			copy.setLocks(this.locks);
			if (!oPr || false !== oPr.cacheImage) {
				copy.cachedImage = this.getBase64Img();
				copy.cachedPixH = this.cachedPixH;
				copy.cachedPixW = this.cachedPixW;
			}
			if (this.txXfrm) {
				copy.setTxXfrm(this.txXfrm.createDuplicate());
			}
			copy.setModelId(this.modelId);
		};

		CShape.prototype.copy = function (oPr) {
			var copy = new CShape();
			this.fillObject(copy, oPr);
			return copy;
		};
		CShape.prototype.getProtectionLockText = function () {
			return this.fLocksText !== false;
		};

		CShape.prototype.canEditText = function () {
			let form = this.isForm && this.isForm() ? this.getInnerForm() : null;
			if (form && !form.CanPlaceCursorInside())
				return false;
			
			return this.superclass.prototype.canEditText.call(this);
		};
		CShape.prototype.canEditTextInSmartArt = function () {
			if (this.isObjectInSmartArt()) {
				var pointContent = this.getSmartArtPointContent();
				var shapePoint = this.getSmartArtShapePoint();
				return !!(pointContent && pointContent.length !== 0 && !shapePoint.isBlipFillPlaceholder());
			}
		}

		CShape.prototype.isPlaceholderInSmartArt = function () {
			if (this.isObjectInSmartArt()) {
				var pointContent = this.getSmartArtPointContent();
				if (pointContent && pointContent.length !== 0) {
					return pointContent.every(function (node) {
						const point = node.point;
						return point && point.prSet && point.prSet.phldr;
					})
				}
			}
			return false;
		};

		CShape.prototype.getSmartArtDefaultTxFill = function () {
			if (this.isObjectInSmartArt()) {
				return this.group.group.getSmartArtDefaultTxFill(this);
			}
		};

		CShape.prototype.Get_Styles = function (level) {

			var _level = AscFormat.isRealNumber(level) ? level : 0;
			if (this.recalcInfo.recalculateTextStyles[_level]) {
				this.recalculateTextStyles(_level);
				this.recalcInfo.recalculateTextStyles[_level] = false;
			}
			this.recalcInfo.recalculateTextStyles[_level] = true;
			var ret = this.compiledStyles[_level];
			this.compiledStyles[_level] = undefined;
			return ret;
			//   return this.compiledStyles[_level];
		};


		CShape.prototype.recalculateTextStyles = function (level) {
			return AscFormat.ExecuteNoHistory(function () {
				const logicDocument = this.getLogicDocument();
				var parent_objects = this.getParentObjects();
				var default_style = new CStyle("defaultStyle", null, null, null, true);
				default_style.ParaPr.Spacing.LineRule = Asc.linerule_Auto;
				default_style.ParaPr.Spacing.Line = 1;
				default_style.ParaPr.Spacing.Before = 0;
				default_style.ParaPr.Spacing.After = 0;
				default_style.ParaPr.DefaultTab = 25.4;
				default_style.ParaPr.Align = AscCommon.align_Center;
				if (logicDocument && logicDocument.IsDocumentEditor()) {
					const documentStyles = logicDocument.Get_Styles();
					if (documentStyles) {
						default_style.TextPr.Lang.Merge(documentStyles.Default.TextPr.Lang);
					}
				}
				if (parent_objects.theme) {
					default_style.TextPr.RFonts.SetFontStyle(AscFormat.fntStyleInd_minor);
				}
				if (!this.bCheckAutoFitFlag) {
					var oBodyPr = this.getBodyPr && this.getBodyPr();
					if (oBodyPr) {
						default_style.ParaPr.LnSpcReduction = oBodyPr.getLnSpcReduction();
						default_style.TextPr.FontScale = oBodyPr.getFontScale();
					}
				} else {
					if (this.tmpLnSpcReduction !== null && this.tmpLnSpcReduction !== undefined) {
						default_style.ParaPr.LnSpcReduction = this.tmpLnSpcReduction / 100000.0;
					}
					if (this.tmpFontScale !== null && this.tmpFontScale !== undefined) {
						default_style.TextPr.FontScale = this.tmpFontScale / 100000.0;
					}

				}
				if (this.getObjectType && this.getObjectType() === AscDFH.historyitem_type_GraphicFrame) {
					default_style.TextPr.FontSize = 18;
				}
				if (isRealObject(parent_objects.presentation) && isRealObject(parent_objects.presentation.defaultTextStyle)) {

					if (isRealObject(parent_objects.presentation.defaultTextStyle.levels[9])) {
						var default_ppt_style = parent_objects.presentation.defaultTextStyle.levels[9];
						default_style.ParaPr.Merge(default_ppt_style.Copy());
						default_ppt_style.DefaultRunPr && default_style.TextPr.Merge(default_ppt_style.DefaultRunPr.Copy());
					}
					if (!isRealObject(parent_objects.master) || !isRealObject(parent_objects.master.txStyles) || !this.isPlaceholder()) {
						if (isRealObject(parent_objects.presentation.defaultTextStyle.levels[level])) {
							var default_ppt_style = parent_objects.presentation.defaultTextStyle.levels[level];
							default_style.ParaPr.Merge(default_ppt_style.Copy());
							default_ppt_style.DefaultRunPr && default_style.TextPr.Merge(default_ppt_style.DefaultRunPr.Copy());
						}
					}
				}

				var master_style;
				if (isRealObject(parent_objects.master) && isRealObject(parent_objects.master.txStyles)) {
					var master_ppt_styles;
					master_style = new CStyle("masterStyle", null, null, null, true);
					if (parent_objects.master.kind === AscFormat.TYPE_KIND.NOTES_MASTER) {
						master_ppt_styles = parent_objects.master.txStyles;
					} else {
						if (this.isPlaceholder() && !(this instanceof AscFormat.CGraphicFrame)) {
							master_ppt_styles = parent_objects.master.txStyles.getStyleByPhType(this.getPlaceholderType());
						} else {
							master_ppt_styles = parent_objects.master.txStyles.otherStyle;
						}
					}

					if (isRealObject(master_ppt_styles) && isRealObject(master_ppt_styles.levels) && isRealObject(master_ppt_styles.levels[level])) {
						var master_ppt_style = master_ppt_styles.levels[level];
						master_style.ParaPr = master_ppt_style.Copy();
						if (master_ppt_style.DefaultRunPr) {
							master_style.TextPr = master_ppt_style.DefaultRunPr.Copy();
						}
					}
				}

				var hierarchy = this.getHierarchy(false);
				var hierarchy_styles = [];
				for (var i = 0; i < hierarchy.length; ++i) {
					var hierarchy_shape = hierarchy[i];
					if (isRealObject(hierarchy_shape)
						&& isRealObject(hierarchy_shape.txBody)
						&& isRealObject(hierarchy_shape.txBody.lstStyle)
						&& isRealObject(hierarchy_shape.txBody.lstStyle.levels)
						&& isRealObject(hierarchy_shape.txBody.lstStyle.levels[level])) {
						var hierarchy_ppt_style = hierarchy_shape.txBody.lstStyle.levels[level];
						var hierarchy_style = new CStyle("hierarchyStyle" + i, null, null, null, true);
						hierarchy_style.ParaPr = hierarchy_ppt_style.Copy();
						if (hierarchy_ppt_style.DefaultRunPr) {
							hierarchy_style.TextPr = hierarchy_ppt_style.DefaultRunPr.Copy();
						}
						hierarchy_styles.push(hierarchy_style);
					}
				}

				var ownStyle;
				if (isRealObject(this.txBody) && isRealObject(this.txBody.lstStyle) && isRealObject(this.txBody.lstStyle.levels[level])) {
					ownStyle = new CStyle("ownStyle", null, null, null, true);
					var own_ppt_style = this.txBody.lstStyle.levels[level];
					ownStyle.ParaPr = own_ppt_style.Copy();
					if (own_ppt_style.DefaultRunPr) {
						ownStyle.TextPr = own_ppt_style.DefaultRunPr.Copy();
					}
					hierarchy_styles.splice(0, 0, ownStyle);
				}
				else if (Asc.editor.isPdfEditor()) {
					let oDoc		= Asc.editor.getPDFDoc();
					let aListStyle	= oDoc.styles.txStyles.otherStyle;

					ownStyle = new CStyle("ownStyle", null, null, null, true);
					var own_ppt_style = aListStyle.levels[level];
					ownStyle.ParaPr = own_ppt_style.Copy();
					if (own_ppt_style.DefaultRunPr) {
						ownStyle.TextPr = own_ppt_style.DefaultRunPr.Copy();
					}
					hierarchy_styles.splice(0, 0, ownStyle);
				}

				var shape_text_style;
				var compiled_style = this.getCompiledStyle && this.getCompiledStyle();
				if (isRealObject(compiled_style) && isRealObject(compiled_style.fontRef)) {
					shape_text_style = new CStyle("shapeTextStyle", null, null, null, true);
					shape_text_style.TextPr.RFonts.SetFontStyle(compiled_style.fontRef.idx);
					if (compiled_style.fontRef.Color && compiled_style.fontRef.Color.isCorrect()) {
						shape_text_style.TextPr.Unifill = AscFormat.CreateUniFillByUniColor(compiled_style.fontRef.Color);
					}
					var smartArtTxFill = this.getSmartArtDefaultTxFill();
					if (smartArtTxFill) {
						shape_text_style.TextPr.Unifill = smartArtTxFill;
					}
				}
				var Styles = new CStyles(false);


				var last_style_id;
				var b_checked = false;
				var isPlaceholder = this.isPlaceholder();
				if (isPlaceholder || this.graphicObject instanceof CTable) {
					if (default_style) {
						//checkTextPr(default_style.TextPr);
						b_checked = true;
						Styles.Add(default_style);
						default_style.BasedOn = null;
						last_style_id = default_style.Id;
					}

					if (master_style) {
						//checkTextPr(master_style.TextPr);
						Styles.Add(master_style);
						master_style.BasedOn = last_style_id;
						last_style_id = master_style.Id;
					}
				} else {
					if (master_style) {
						// checkTextPr(master_style.TextPr);
						b_checked = true;
						Styles.Add(master_style);
						master_style.BasedOn = null;
						last_style_id = master_style.Id;
					}

					if (default_style) {
						//checkTextPr(default_style.TextPr);
						Styles.Add(default_style);
						default_style.BasedOn = last_style_id;
						last_style_id = default_style.Id;
					}
				}

				for (var i = hierarchy_styles.length - 1; i > -1; --i) {

					if (hierarchy_styles[i]) {
						//checkTextPr(hierarchy_styles[i].TextPr);
						Styles.Add(hierarchy_styles[i]);
						hierarchy_styles[i].BasedOn = last_style_id;
						last_style_id = hierarchy_styles[i].Id;
					}
				}


				if (shape_text_style) {
					//checkTextPr(shape_text_style.TextPr);
					Styles.Add(shape_text_style);
					shape_text_style.BasedOn = last_style_id;
					last_style_id = shape_text_style.Id;
				}

				this.compiledStyles[level] = {
					styles: Styles,
					lastId: last_style_id,
					shape: this,
					slide: parent_objects.slide,
					layout: parent_objects.layout,
					master: parent_objects.master,
					presentation: parent_objects.presentation,
					notes: parent_objects.notes
				};
				return this.compiledStyles[level];
			}, this, []);
		};

		CShape.prototype.recalculateBrush = function () {
			let parents = this.getParentObjects();
			let RGBA = {R: 0, G: 0, B: 0, A: 255};
			if(this.useBgFill) {
				if(this.parent && this.parent.backgroundFill) {
					this.brush = this.parent.backgroundFill.createDuplicate();
					this.brush.calculate(parents.theme, parents.slide, parents.layout, parents.master, RGBA);
					return;
				}
			}
			let compiled_style = this.getCompiledStyle();
			let oStyleBrush = null;
			let oLin;
			if (isRealObject(parents.theme) && isRealObject(compiled_style) && isRealObject(compiled_style.fillRef)) {
				this.brush = parents.theme.getFillStyle(compiled_style.fillRef.idx, compiled_style.fillRef.Color);
				if (this.brush) {
					oStyleBrush = this.brush.createDuplicate();
				}
			} else {
				this.brush = AscFormat.CreateNoFillUniFill();
			}

			this.brush.merge(this.getCompiledFill());
			this.brush.transparent = this.getCompiledTransparent();
			this.brush.calculate(parents.theme, parents.slide, parents.layout, parents.master, RGBA);
			if (this.brush.fill && this.brush.fill.type === Asc.c_oAscFill.FILL_TYPE_GRAD) {
				var oGradFill = this.brush.fill;
				if (!oGradFill.lin && !oGradFill.path) {
					if (oStyleBrush &&
						oStyleBrush.fill &&
						oStyleBrush.fill.type === Asc.c_oAscFill.FILL_TYPE_GRAD &&
						oStyleBrush.fill.lin) {
						oLin = oStyleBrush.fill.lin.createDuplicate();
					} else {
						oLin = new AscFormat.GradLin();
						oLin.setScale(false);
						oLin.setAngle(0);
						oGradFill.setLin(oLin);
					}
					oGradFill.setLin(oLin);
				}
			}
		};

		CShape.prototype.recalculatePen = function () {
			var compiled_style = this.getCompiledStyle();
			var RGBA = {R: 0, G: 0, B: 0, A: 255};
			var parents = this.getParentObjects();
			if (isRealObject(parents.theme) && isRealObject(compiled_style) && isRealObject(compiled_style.lnRef)) {
				//compiled_style.lnRef.Color.Calculate(parents.theme, parents.slide, parents.layout, parents.master, {R: 0, G: 0, B: 0, A:255});
				//RGBA = compiled_style.lnRef.Color.RGBA;
				// compiled_style is default style
				this.pen = parents.theme.getLnStyle(compiled_style.lnRef.idx, compiled_style.lnRef.Color);
				//if (isRealObject(this.pen)) {
				//    if (isRealObject(compiled_style.lnRef.Color.color)
				//        && isRealObject(this.pen)
				//        && isRealObject(this.pen.Fill)
				//        && isRealObject(this.pen.Fill.fill)
				//        && this.pen.Fill.fill.type === FILL_TYPE_SOLID) {
				//        this.pen.Fill.fill.color = compiled_style.lnRef.Color.createDuplicate();
				//    }
				//}
				//else
				//{
				//    this.pen = new AscFormat.CLn();
				//}
			} else {
				this.pen = null;
			}

			// compiled line is given line props object
			var oCompiledLine = this.getCompiledLine();
			if (oCompiledLine) {
				if (!this.pen) {
					this.pen = new AscFormat.CLn();
				}
				this.pen.merge(oCompiledLine);
			}
			if (this.pen) {
				this.pen.calculate(parents.theme, parents.slide, parents.layout, parents.master, RGBA);
			}
		};

		CShape.prototype.Get_ParentTextTransform = function () {
			return this.transformText.CreateDublicate();
		};
		CShape.prototype.canAddButtonPlaceholder = function () {
			return AscFormat.isSlideLikeObject(this.parent) || this.isObjectInSmartArt();
		};
		CShape.prototype.isEmptyPlaceholder = function (bDefaultEmpty) {
			if (this.isObjectInSmartArt()) {
				if (this.isPlaceholderInSmartArt()) {
					if (this.txBody) {
						if (this.txBody.content) {
							return this.txBody.content.Is_Empty(bDefaultEmpty);
						}
						return true;
					}
				} else if (this.isActiveBlipFillPlaceholder()) {
					return true;
				}
			}
			if (this.isPlaceholder()) {
				var phldrType = this.getPlaceholderType();
				if (phldrType == AscFormat.phType_title
					|| phldrType == AscFormat.phType_ctrTitle
					|| phldrType == AscFormat.phType_body
					|| phldrType == AscFormat.phType_subTitle
					|| phldrType == null
					|| phldrType == AscFormat.phType_dt
					|| phldrType == AscFormat.phType_ftr
					|| phldrType == AscFormat.phType_hdr
					|| phldrType == AscFormat.phType_sldNum
					|| phldrType == AscFormat.phType_dgm
					|| phldrType == AscFormat.phType_sldImg) {
					if (this.txBody) {
						if (this.txBody.content) {
							return this.txBody.content.Is_Empty();
						}
						return true;
					}
					return true;
				}
				if (phldrType == AscFormat.phType_chart
					|| phldrType == AscFormat.phType_media) {
					return true;
				}
				if (phldrType == AscFormat.phType_pic
					|| phldrType == AscFormat.phType_tbl) {
					var _b_empty_text = true;
					if (this.txBody) {
						if (this.txBody.content) {
							_b_empty_text = this.txBody.content.Is_Empty();
						}
					}
					return (_b_empty_text /* && (this.brush == null || this.brush.fill == null)*/);
				}
			} else {
				return false;
			}
		};


		CShape.prototype.changeSize = function (kw, kh) {
			if (this.spPr && this.spPr.xfrm && this.spPr.xfrm.isNotNull()) {
				var xfrm = this.spPr.xfrm;
				// if(this.getNoChangeAspect()){
				//     var k = Math.min(kw, kh);
				//     var oldXC = xfrm.offX + xfrm.extX/2.0;
				//     var oldYC = xfrm.offY + xfrm.extY/2.0;
				//     xfrm.setExtX(xfrm.extX * k);
				//     xfrm.setExtY(xfrm.extY * k);
				//     xfrm.setOffX(oldXC * kw - xfrm.extX/2.0);
				//     xfrm.setOffY(oldYC * kh - xfrm.extY/2.0);
				// }
				// else
				{

					xfrm.setOffX(xfrm.offX * kw);
					xfrm.setOffY(xfrm.offY * kh);
					xfrm.setExtX(xfrm.extX * kw);
					xfrm.setExtY(xfrm.extY * kh);
				}
			}
			var txXfrm = this.txXfrm;
			if (txXfrm && txXfrm.isNotNull()) {

				txXfrm.setOffX(txXfrm.offX * kw);
				txXfrm.setOffY(txXfrm.offY * kh);
				txXfrm.setExtX(txXfrm.extX * kw);
				txXfrm.setExtY(txXfrm.extY * kh);

			}
			this.recalcTransform && this.recalcTransform();
		};

		CShape.prototype.recalculateTransform = function () {
			this.cachedImage = null;
			this.recalculateLocalTransform(this.transform);
			this.invertTransform = global_MatrixTransformer.Invert(this.transform);
			this.localTransform = this.transform.CreateDublicate();
		};


		CShape.prototype.checkAutofit = function (bIgnoreWordShape) {
			if (this.bWordShape || bIgnoreWordShape || this.bCheckAutoFitFlag) {
				var content = this.getDocContent();
				if (content) {
					var oBodyPr = this.getBodyPr();
					if (oBodyPr.textFit && oBodyPr.textFit.type === AscFormat.text_fit_Auto || oBodyPr.wrap === AscFormat.nTWTNone) {
						return true;
					}
				}
			}
			return false;
		};

		CShape.prototype.Check_AutoFit = function () {
			return this.checkAutofit(true) || this.checkContentWordArt(this.getDocContent()) || this.getBodyPr().prstTxWarp != null;
		};

		CShape.prototype.recalculateLocalTransform = function (transform) {
			AscFormat.ExecuteNoHistory(function () {
				var bNotesShape = false;

				let oParaDrawing = getParaDrawing(this);
				if (!isRealObject(this.group)) {
					var bUserShape = false;
					if (this.parent instanceof AscFormat.CRelSizeAnchor || this.parent instanceof AscFormat.CAbsSizeAnchor) {
						if (this.parent.parent instanceof AscFormat.CChartSpace) {
							this.x = this.parent.parent.extX * this.parent.fromX;
							this.y = this.parent.parent.extY * this.parent.fromY;
							if (this.parent instanceof AscFormat.CRelSizeAnchor) {
								this.extX = Math.max(0.0, this.parent.parent.extX * this.parent.toX - this.x);
								this.extY = Math.max(0.0, this.parent.parent.extY * this.parent.toY - this.y);
							} else {
								this.extX = Math.max(0.0, this.parent.toX);
								this.extY = Math.max(0.0, this.parent.toY);
							}
							var rot = 0;
							if (this.spPr && this.spPr.xfrm) {
								if (AscFormat.isRealNumber(this.spPr.xfrm.rot)) {
									rot = AscFormat.normalizeRotate(this.spPr.xfrm.rot);
								}
								this.flipH = this.spPr.xfrm.flipH === true;
								this.flipV = this.spPr.xfrm.flipV === true;
							}
							this.rot = rot;
							bUserShape = true;
						}
					}
					if (bUserShape) {
					} else if (this.drawingBase && !this.isCrop) {
						var metrics = this.drawingBase.getGraphicObjectMetrics();
						this.x = metrics.x;
						this.y = metrics.y;
						var rot = 0;
						if (this.spPr && this.spPr.xfrm) {
							if (AscFormat.isRealNumber(this.spPr.xfrm.rot)) {
								rot = AscFormat.normalizeRotate(this.spPr.xfrm.rot);
							}
							this.flipH = this.spPr.xfrm.flipH === true;
							this.flipV = this.spPr.xfrm.flipV === true;
						}
						this.rot = rot;

						var metricExtX, metricExtY;
						//  if(!(this instanceof AscFormat.CGroupShape))
						{
							metricExtX = metrics.extX;
							metricExtY = metrics.extY;
							if (checkNormalRotate(rot)) {
								this.extX = metrics.extX;
								this.extY = metrics.extY;
							} else {
								this.extX = metrics.extY;
								this.extY = metrics.extX;
							}
						}
						// else
						// {
						//     if(this.spPr && this.spPr.xfrm && AscFormat.isRealNumber(this.spPr.xfrm.extX) && AscFormat.isRealNumber(this.spPr.xfrm.extY))
						//     {
						//         this.extX = this.spPr.xfrm.extX;
						//         this.extY = this.spPr.xfrm.extY;
						//     }
						//     else
						//     {
						//         metricExtX = metrics.extX;
						//         metricExtY = metrics.extY;
						//     }
						// }

						if (checkNormalRotate(rot)) {
							this.x = metrics.x;
							this.y = metrics.y;
						} else {
							this.x = metrics.x + metricExtX / 2 - metricExtY / 2;
							this.y = metrics.y + metricExtY / 2 - metricExtX / 2;
						}
					} else if (typeof AscCommonSlide !== "undefined" && AscCommonSlide
						&& AscCommonSlide.CNotes && this.parent && this.parent instanceof AscCommonSlide.CNotes) {
						bNotesShape = true;
						this.x = 0;
						this.y = editor.WordControl.m_oLogicDocument.GetHeightMM();
						this.extX = this.parent.getWidth();
						this.extY = 2000;
						this.rot = 0;
						this.flipH = false;
						this.flipV = false;
					} else if (this.spPr && this.spPr.xfrm && this.spPr.xfrm.isNotNull()) {
						var xfrm = this.spPr.xfrm;
						let bDoNotUseOffset = false;
						if (this.parent) {
							if (this.parent.PositionH && this.parent.PositionV) {
								bDoNotUseOffset = true;
							}
						}
						if (bDoNotUseOffset) {
							this.x = 0;
							this.y = 0;
						} else {
							this.x = xfrm.offX;
							this.y = xfrm.offY;
						}
						let isTable = (this.isTable && this.isTable());
						if(!isTable) {
							this.extX = xfrm.extX;
							this.extY = xfrm.extY;
						}
						this.rot = AscFormat.isRealNumber(xfrm.rot) ? xfrm.rot : 0;
						this.flipH = xfrm.flipH === true;
						this.flipV = xfrm.flipV === true;

						if (oParaDrawing) {
							if (oParaDrawing.Extent && AscFormat.isRealNumber(oParaDrawing.Extent.W) && AscFormat.isRealNumber(oParaDrawing.Extent.H)) {
								let dScaleCoefficient = this.getScaleCoefficient();
								this.extX = oParaDrawing.Extent.W * dScaleCoefficient;
								this.extY = oParaDrawing.Extent.H * dScaleCoefficient;
							}
							if (oParaDrawing.SizeRelH || oParaDrawing.SizeRelV) {
								this.m_oSectPr = null;
								var oParentParagraph = oParaDrawing.Get_ParentParagraph();
								if (oParentParagraph) {

									var oSectPr = oParentParagraph.Get_SectPr();
									if (oSectPr) {
										if (oParaDrawing.SizeRelH && oParaDrawing.SizeRelH.Percent > 0) {
											switch (oParaDrawing.SizeRelH.RelativeFrom) {
												case c_oAscSizeRelFromH.sizerelfromhMargin: {
													this.extX = oSectPr.GetContentFrameWidth();
													break;
												}
												case c_oAscSizeRelFromH.sizerelfromhPage: {
													this.extX = oSectPr.GetPageWidth();
													break;
												}
												case c_oAscSizeRelFromH.sizerelfromhLeftMargin: {
													this.extX = oSectPr.GetPageMarginLeft();
													break;
												}

												case c_oAscSizeRelFromH.sizerelfromhRightMargin: {
													this.extX = oSectPr.GetPageMarginRight();
													break;
												}
												default: {
													this.extX = oSectPr.GetPageMarginLeft();
													break;
												}
											}
											this.extX *= oParaDrawing.SizeRelH.Percent;
										}
										if (oParaDrawing.SizeRelV && oParaDrawing.SizeRelV.Percent > 0) {
											switch (oParaDrawing.SizeRelV.RelativeFrom) {
												case c_oAscSizeRelFromV.sizerelfromvMargin: {
													this.extY = oSectPr.GetContentFrameHeight();
													break;
												}
												case c_oAscSizeRelFromV.sizerelfromvPage: {
													this.extY = oSectPr.GetPageHeight();
													break;
												}
												case c_oAscSizeRelFromV.sizerelfromvTopMargin: {
													this.extY = oSectPr.GetPageMarginTop();
													break;
												}
												case c_oAscSizeRelFromV.sizerelfromvBottomMargin: {
													this.extY = oSectPr.GetPageMarginBottom();
													break;
												}
												default: {
													this.extY = oSectPr.GetPageMarginTop();
													break;
												}
											}
											this.extY *= oParaDrawing.SizeRelV.Percent;
										}
										this.m_oSectPr = new AscWord.SectPr();
										this.m_oSectPr.Copy(oSectPr);
									}
								}
							}
						}
					} else {
						if (this.isPlaceholder()) {
							var hierarchy = this.getHierarchy();
							for (var i = 0; i < hierarchy.length; ++i) {
								var hierarchy_sp = hierarchy[i];
								if (isRealObject(hierarchy_sp) && hierarchy_sp.spPr.xfrm && hierarchy_sp.spPr.xfrm.isNotNull()) {
									var xfrm = hierarchy_sp.spPr.xfrm;
									this.x = xfrm.offX;
									this.y = xfrm.offY;
									this.extX = xfrm.extX;
									this.extY = xfrm.extY;
									this.rot = AscFormat.isRealNumber(xfrm.rot) ? xfrm.rot : 0;
									this.flipH = xfrm.flipH === true;
									this.flipV = xfrm.flipV === true;
									break;
								}
							}
							if (i === hierarchy.length) {
								this.x = 0;
								this.y = 0;
								this.extX = 5;
								this.extY = 5;
								this.rot = 0;
								this.flipH = false;
								this.flipV = false;
							}
						} else {
							var extX, extY;
							if (oParaDrawing && oParaDrawing.Extent) {
								this.x = 0;
								this.y = 0;
								let dScaleCoefficient = oParaDrawing.GetScaleCoefficient();
								extX = oParaDrawing.Extent.W * dScaleCoefficient;
								extY = oParaDrawing.Extent.H * dScaleCoefficient;
							} else {
								this.x = 0;
								this.y = 0;
								extX = 5;
								extY = 5;
							}
							this.extX = extX;
							this.extY = extY;
							this.rot = 0;
							this.flipH = false;
							this.flipV = false;
						}
					}
				} else {
					let oOwnXfrm = this.spPr && this.spPr.xfrm;
					var xfrm;
					if (oOwnXfrm && oOwnXfrm.isNotNull()) {
						xfrm = oOwnXfrm;
					} else {
						if (this.isPlaceholder()) {
							var hierarchy = this.getHierarchy();
							for (var i = 0; i < hierarchy.length; ++i) {
								var hierarchy_sp = hierarchy[i];
								if (isRealObject(hierarchy_sp) && hierarchy_sp.spPr.xfrm.isNotNull()) {
									xfrm = hierarchy_sp.spPr.xfrm;
									break;
								}
							}
							if (i === hierarchy.length) {
								xfrm = new AscFormat.CXfrm();
								xfrm.offX = 0;
								xfrm.offX = 0;
								xfrm.extX = 0;
								xfrm.extY = 0;
								xfrm.merge(oOwnXfrm);
							}
						} else {
							xfrm = new AscFormat.CXfrm();
							xfrm.offX = 0;
							xfrm.offY = 0;
							xfrm.extX = 0;
							xfrm.extY = 0;
							xfrm.merge(oOwnXfrm);
						}
					}


					var scale_scale_coefficients = this.group.getResultScaleCoefficients();

					let offX = xfrm.offX;
					let offY = xfrm.offY;
					let oGrXfrm = null;
					if(this.group.spPr) {
						oGrXfrm = this.group.spPr.xfrm;
						if(oGrXfrm) {
							offX -= oGrXfrm.chOffX;
							offY -= oGrXfrm.chOffY;
						}
					}
					this.x = scale_scale_coefficients.cx * offX;
					this.y = scale_scale_coefficients.cy * offY;
					this.extX = scale_scale_coefficients.cx * xfrm.extX;
					this.extY = scale_scale_coefficients.cy * xfrm.extY;
					this.rot = AscFormat.isRealNumber(xfrm.rot) ? xfrm.rot : 0;
					this.flipH = xfrm.flipH === true;
					this.flipV = xfrm.flipV === true;
				}


				if (this.checkAutofit && this.checkAutofit() &&
					(!this.bWordShape || !this.group || this.bCheckAutoFitFlag) && !bNotesShape) {
					var oBodyPr = this.getBodyPr();
					if (this.bWordShape) {
						if (this.recalcInfo.recalculateTxBoxContent) {
							this.recalcInfo.oContentMetrics = this.recalculateTxBoxContent();
							//this.recalcInfo.recalculateTxBoxContent = false;
							this.recalcInfo.AllDrawings = [];
							var oContent = this.getDocContent();
							if (oContent) {
								oContent.GetAllDrawingObjects(this.recalcInfo.AllDrawings);
							}
						}
					} else {
						if (this.recalcInfo.recalculateContent) {
							this.recalcInfo.oContentMetrics = this.recalculateContent();
							this.recalcInfo.recalculateContent = false;
						}
					}
					var oContentMetrics = this.recalcInfo.oContentMetrics;

					var l_ins, t_ins, r_ins, b_ins;
					if (oBodyPr) {
						l_ins = AscFormat.isRealNumber(oBodyPr.lIns) ? oBodyPr.lIns : 2.54;
						r_ins = AscFormat.isRealNumber(oBodyPr.rIns) ? oBodyPr.rIns : 2.54;
						t_ins = AscFormat.isRealNumber(oBodyPr.tIns) ? oBodyPr.tIns : 1.27;
						b_ins = AscFormat.isRealNumber(oBodyPr.bIns) ? oBodyPr.bIns : 1.27;
					} else {
						l_ins = 2.54;
						r_ins = 2.54;
						t_ins = 1.27;
						b_ins = 1.27;
					}
					var oGeometry = this.spPr && this.spPr.geometry, oWH;
					var dOldExtX = this.extX, dOldExtY = this.extY, dDeltaX = 0, dDeltaY = 0;


					var bAutoFit = AscCommon.isRealObject(oBodyPr.textFit) && oBodyPr.textFit.type === AscFormat.text_fit_Auto;
					if (oBodyPr.wrap === AscFormat.nTWTNone) {
						if (!oBodyPr.upright) {
							if (!(oBodyPr.vert === AscFormat.nVertTTvert || oBodyPr.vert === AscFormat.nVertTTvert270 || oBodyPr.vert === AscFormat.nVertTTeaVert)) {
								if (oGeometry) {
									oWH = oGeometry.getNewWHByTextRect(oContentMetrics.w + l_ins + r_ins, oContentMetrics.contentH + t_ins + b_ins, undefined, bAutoFit ? undefined : this.extY);
									if (!oWH.bError) {
										this.extX = oWH.W;
										this.extY = oWH.H;
									}
								} else {
									this.extX = oContentMetrics.w + l_ins + r_ins;
									this.extY = bAutoFit ? oContentMetrics.contentH + t_ins + b_ins : this.extY;
								}

							} else {
								if (oGeometry) {
									oWH = oGeometry.getNewWHByTextRect(oContentMetrics.contentH + l_ins + r_ins, oContentMetrics.w + t_ins + b_ins, bAutoFit ? undefined : this.extX);
									if (!oWH.bError) {
										this.extX = oWH.W;
										this.extY = oWH.H;
									}
								} else {
									this.extY = oContentMetrics.w + t_ins + b_ins;
									this.extX = bAutoFit ? oContentMetrics.contentH + l_ins + r_ins : this.extX;
								}
							}
						} else {
							var _full_rotate = this.getFullRotate();
							if (checkNormalRotate(_full_rotate)) {
								if (!(oBodyPr.vert === AscFormat.nVertTTvert || oBodyPr.vert === AscFormat.nVertTTvert270 || oBodyPr.vert === AscFormat.nVertTTeaVert)) {

									if (oGeometry) {
										oWH = oGeometry.getNewWHByTextRect(oContentMetrics.w + l_ins + r_ins, oContentMetrics.contentH + t_ins + b_ins, undefined, bAutoFit ? undefined : this.extY);
										if (!oWH.bError) {
											this.extX = oWH.W;
											this.extY = oWH.H;
										}
									} else {
										this.extX = oContentMetrics.w + l_ins + r_ins;
										this.extY = bAutoFit ? oContentMetrics.contentH + t_ins + b_ins : this.extY;
									}
								} else {
									if (oGeometry) {
										oWH = oGeometry.getNewWHByTextRect(oContentMetrics.contentH + l_ins + r_ins, oContentMetrics.w + t_ins + b_ins, bAutoFit ? undefined : this.extX);
										if (!oWH.bError) {
											this.extX = oWH.W;
											this.extY = oWH.H;
										}
									} else {
										this.extY = oContentMetrics.w + t_ins + b_ins;
										this.extX = bAutoFit ? oContentMetrics.contentH + l_ins + r_ins : this.extX;
									}

								}
							} else {
								if (!(oBodyPr.vert === AscFormat.nVertTTvert || oBodyPr.vert === AscFormat.nVertTTvert270 || oBodyPr.vert === AscFormat.nVertTTeaVert)) {
									if (oGeometry) {
										oWH = oGeometry.getNewWHByTextRect(oContentMetrics.w + l_ins + r_ins, oContentMetrics.contentH + t_ins + b_ins, undefined, bAutoFit ? undefined : this.extY);
										if (!oWH.bError) {
											this.extX = oWH.W;
											this.extY = oWH.H;
										}
									} else {
										this.extX = oContentMetrics.w + l_ins + r_ins;
										this.extY = bAutoFit ? oContentMetrics.contentH + t_ins + b_ins : this.extY;
									}
								} else {
									if (oGeometry) {
										oWH = oGeometry.getNewWHByTextRect(oContentMetrics.contentH + l_ins + r_ins, oContentMetrics.w + t_ins + b_ins, bAutoFit ? undefined : this.extX);
										if (!oWH.bError) {
											this.extX = oWH.W;
											this.extY = oWH.H;
										}
									} else {
										this.extY = oContentMetrics.w + t_ins + b_ins;
										this.extX = bAutoFit ? oContentMetrics.contentH + l_ins + r_ins : this.extX;
									}
								}
							}
						}
					} else {
						if (!oBodyPr.upright) {
							if (!(oBodyPr.vert === AscFormat.nVertTTvert || oBodyPr.vert === AscFormat.nVertTTvert270 || oBodyPr.vert === AscFormat.nVertTTeaVert)) {
								if (oGeometry) {
									oWH = oGeometry.getNewWHByTextRect(undefined, oContentMetrics.contentH + t_ins + b_ins, this.extX, undefined);
									if (!oWH.bError) {
										this.extY = oWH.H;
									}
								} else {
									this.extY = oContentMetrics.contentH + t_ins + b_ins;
								}
							} else {
								if (oGeometry) {
									oWH = oGeometry.getNewWHByTextRect(oContentMetrics.contentH + l_ins + b_ins, undefined, undefined, this.extY);
									if (!oWH.bError) {
										this.extX = oWH.W;
									}
								} else {
									this.extX = oContentMetrics.contentH + l_ins + r_ins;
								}
							}
						} else {
							var _full_rotate = this.getFullRotate();
							if (checkNormalRotate(_full_rotate)) {
								if (!(oBodyPr.vert === AscFormat.nVertTTvert || oBodyPr.vert === AscFormat.nVertTTvert270 || oBodyPr.vert === AscFormat.nVertTTeaVert)) {
									if (oGeometry) {
										oWH = oGeometry.getNewWHByTextRect(undefined, oContentMetrics.contentH + t_ins + b_ins, this.extX, undefined);
										if (!oWH.bError) {
											this.extY = oWH.H;
										}
									} else {
										this.extY = oContentMetrics.contentH + t_ins + b_ins;
									}
								} else {
									if (oGeometry) {
										oWH = oGeometry.getNewWHByTextRect(oContentMetrics.contentH + l_ins + r_ins, undefined, undefined, this.extY);
										if (!oWH.bError) {
											this.extX = oWH.W;
										}
									} else {
										this.extX = oContentMetrics.contentH + l_ins + r_ins;
									}
								}
							} else {
								if (!(oBodyPr.vert === AscFormat.nVertTTvert || oBodyPr.vert === AscFormat.nVertTTvert270 || oBodyPr.vert === AscFormat.nVertTTeaVert)) {
									if (oGeometry) {
										oWH = oGeometry.getNewWHByTextRect(oContentMetrics.contentH + l_ins + r_ins, undefined, undefined, this.extY);
										if (!oWH.bError) {
											this.extX = oWH.W;
										}
									} else {
										this.extX = oContentMetrics.contentH + l_ins + r_ins;
									}
								} else {
									if (oGeometry) {
										oWH = oGeometry.getNewWHByTextRect(undefined, oContentMetrics.contentH + t_ins + b_ins, this.extX, undefined);
										if (!oWH.bError) {
											this.extY = oWH.H;
										}
									} else {
										this.extY = oContentMetrics.contentH + t_ins + b_ins;
									}
								}
							}
						}
					}

					if (!this.bWordShape || this.group)//в презентациях и в таблицах изменям позицию: по горизонтали - в зависимости от выравнивания первого параграфа в контенте,
						// по вертикали - в зависимости от вертикального выравнивания контента.
					{
						var dSin = Math.sin(this.rot), dCos = Math.cos(this.rot);
						var oContent = this.getDocContent();
						var nJc, nAnchor;
						if (AscFormat.isRealNumber(this.rot) && !AscFormat.fApproxEqual(this.rot, 0)) {
							nJc = AscCommon.align_Center;
							nAnchor = 1;
						} else {
							nJc = oContent.Content[0].CompiledPr.Pr.ParaPr.Jc;
							nAnchor = oBodyPr.anchor;
						}
						var FreezePointX, FreezePointY;
						switch (nJc) {
							case AscCommon.align_Right: {
								dDeltaX = dOldExtX - this.extX;
								FreezePointX = oContent.XLimit;
								break;
							}
							case AscCommon.align_Left: {
								dDeltaX = 0;
								FreezePointX = 0;
								break;
							}
							default: {
								dDeltaX = (dOldExtX - this.extX) / 2;
								FreezePointX = oContent.XLimit / 2.0;
								break;
							}
						}

						switch (nAnchor) {
							case 0: //b
							{
								dDeltaY = dOldExtY - this.extY;
								FreezePointY = oContent.GetSummaryHeight();
								break;
							}
							case 1:    //ctr
							case 2: //dist
							case 3: //just
							{// (Text Anchor Enum ( Center ))
								dDeltaY = (dOldExtY - this.extY) / 2;
								FreezePointY = oContent.GetSummaryHeight() / 2.0;
								break;
							}
							default: {
								FreezePointY = 0.0;
								break;
							}
						}
						// var tx1 = this.localTransformText.TransformPointX(FreezePointX, FreezePointY);
						// var ty1 = this.localTransformText.TransformPointY(FreezePointX, FreezePointY);
						// this.recalculateTransformText();
						// var tx2 = this.localTransformText.TransformPointX(FreezePointX, FreezePointY);
						// var ty2 = this.localTransformText.TransformPointY(FreezePointX, FreezePointY);


						var dTrDeltaX, dTrDeltaY;
						// if(this.invertTransform)
						// {
						//     var oInvMatrix = this.invertTransform.CreateDublicate();
						//     oInvMatrix.tx = 0.0;
						//     oInvMatrix.ty = 0.0;
						//     dTrDeltaX = oInvMatrix.TransformPointX(dDeltaX, dDeltaY);
						//     dTrDeltaY = oInvMatrix.TransformPointY(dDeltaX, dDeltaY);
						// }
						// else
						{
							dTrDeltaX = dDeltaX;
							dTrDeltaY = dDeltaY;
						}
						this.x += dTrDeltaX;
						this.y += dTrDeltaY;
					}
				}
				this.localX = this.x;
				this.localY = this.y;
				transform.Reset();
				var hc = this.extX * 0.5;
				var vc = this.extY * 0.5;
				global_MatrixTransformer.TranslateAppend(transform, -hc, -vc);
				if (this.flipH)
					global_MatrixTransformer.ScaleAppend(transform, -1, 1);
				if (this.flipV)
					global_MatrixTransformer.ScaleAppend(transform, 1, -1);
				global_MatrixTransformer.RotateRadAppend(transform, -this.rot);
				global_MatrixTransformer.TranslateAppend(transform, this.x + hc, this.y + vc);
				if (isRealObject(this.group)) {
					global_MatrixTransformer.MultiplyAppend(transform, this.group.getLocalTransform());
				}
				if (oParaDrawing) {
					this.m_oSectPr = null;
					var oParentParagraph = oParaDrawing.Get_ParentParagraph();
					if (oParentParagraph) {
						var oSectPr = oParentParagraph.Get_SectPr();
						if (oSectPr) {
							this.m_oSectPr = new AscWord.SectPr();
							this.m_oSectPr.Copy(oSectPr);
						}
					}
				}
				this.localTransform = transform;
				this.transform = transform;
			}, this, []);
		};

		CShape.prototype.CheckNeedRecalcAutoFit = function (oSectPr) {
			var Width, Height, Width2, Height2;
			var bRet = false;
			var oParaDrawing = getParaDrawing(this);
			var bSizRel = (oParaDrawing && (oParaDrawing.SizeRelH || oParaDrawing.SizeRelV));
			if (this.checkAutofit() || bSizRel) {
				if (oSectPr) {
					if (!this.m_oSectPr) {
						this.recalcBounds();
						this.recalcText();
						this.recalcGeometry();
						if (bSizRel) {
							this.recalcTransform();
						}
						bRet = true;
					} else {
						Width = oSectPr.GetContentFrameWidth();
						Height = oSectPr.GetContentFrameHeight();

						Width2 = this.m_oSectPr.GetContentFrameWidth();
						Height2 = this.m_oSectPr.GetContentFrameHeight();

						bRet = (Math.abs(Width - Width2) > 0.001 || Math.abs(Height - Height2) > 0.001);
						if (bRet) {
							this.recalcBounds();
							this.recalcText();
							this.recalcGeometry();
							if (bSizRel) {
								this.recalcTransform();
							}
						}
						return bRet;
					}
				} else {
					if (this.m_oSectPr) {
						this.recalcBounds();
						this.recalcText();
						this.recalcGeometry();
						bRet = true;
					}
				}
			}
			return bRet;
		};


		CShape.prototype._isTextRotated = function(bodyPr) {
			if (!bodyPr) {
				return false;
			}
			
			let isRotated = (bodyPr.vert === AscFormat.nVertTTvert
				|| bodyPr.vert === AscFormat.nVertTTvert270
				|| bodyPr.vert === AscFormat.nVertTTeaVert
			);
			
			if (bodyPr.wrap !== AscFormat.nTWTNone
				&& bodyPr.upright
				&& !checkNormalRotate(this.getFullRotate())) {
				isRotated = !isRotated;
			}
			
			return isRotated;
		};
		CShape.prototype.recalculateDocContent = function (oDocContent, oBodyPr) {
			let nStartPage = this.GetAbsolutePage ? this.GetAbsolutePage() : 0;
			let oRet = {w: 0, h: 0, contentH: 0};
			let oInsets = this.getInsets({bIgnoreInsets: false, bodyPr: oBodyPr});
			const oForm = this.isForm && this.isForm() ? this.getInnerForm() : null;
			let l_ins = oInsets.lIns;
			let t_ins = oInsets.tIns;
			let r_ins = oInsets.rIns;
			let b_ins = oInsets.bIns;
			let oRect = this.getTextRect();
			let w, h;
			w = oRect.r - oRect.l - (l_ins + r_ins);
			h = oRect.b - oRect.t - (t_ins + b_ins);
			if (oBodyPr.wrap === AscFormat.nTWTNone) {
				var dMaxWidth = 100000;
				if (this.bWordShape) {
					this.m_oSectPr = null;
					var oParaDrawing = getParaDrawing(this);
					if (oParaDrawing) {
						var oParentParagraph = oParaDrawing.Get_ParentParagraph();
						if (oParentParagraph) {
							var oSectPr = oParentParagraph.Get_SectPr();
							if (oSectPr) {
								if (!(oBodyPr.vert === AscFormat.nVertTTvert || oBodyPr.vert === AscFormat.nVertTTvert270 || oBodyPr.vert === AscFormat.nVertTTeaVert)) {
									dMaxWidth = oSectPr.GetContentFrameWidth() - l_ins - r_ins;
								} else {
									dMaxWidth = oSectPr.GetContentFrameHeight();
								}
								this.m_oSectPr = new AscWord.SectPr();
								this.m_oSectPr.Copy(oSectPr);
							}
						}
					}
				}
				var dMaxWidthRec = RecalculateDocContentByMaxLine(oDocContent, dMaxWidth, this.bWordShape);
				if (!(oBodyPr.vert === AscFormat.nVertTTvert || oBodyPr.vert === AscFormat.nVertTTvert270 || oBodyPr.vert === AscFormat.nVertTTeaVert)) {
					if (dMaxWidthRec < w && (!this.bWordShape && !this.bCheckAutoFitFlag)) {
						oRet.w = w + TEXT_RECT_ERROR;
						oDocContent.RecalculateContent(oRet.w, h, nStartPage);
						oRet.contentH = oDocContent.GetSummaryHeight();
						oRet.h = oRet.contentH;
					} else {
						oRet.w = dMaxWidthRec + TEXT_RECT_ERROR;
						oDocContent.RecalculateContent(oRet.w, h, nStartPage);
						oRet.contentH = oDocContent.GetSummaryHeight();
						oRet.h = oRet.contentH;
					}
					oRet.correctW = l_ins + r_ins;
					oRet.correctH = t_ins + b_ins;
					oRet.textRectW = w;
					oRet.textRectH = h;
				} else {
					if (dMaxWidthRec < h && !this.bWordShape) {
						oRet.w = h + TEXT_RECT_ERROR;
						oDocContent.RecalculateContent(oRet.w, h, nStartPage);
						oRet.contentH = oDocContent.GetSummaryHeight();
						oRet.h = oRet.contentH;
					} else {
						oRet.w = dMaxWidthRec + TEXT_RECT_ERROR;
						oDocContent.RecalculateContent(oRet.w, h, nStartPage);
						oRet.contentH = oDocContent.GetSummaryHeight();
						oRet.h = oRet.contentH;
					}
					oRet.correctW = t_ins + b_ins;
					oRet.correctH = l_ins + r_ins;
					oRet.textRectW = h;
					oRet.textRectH = w;
				}
			} else//AscFormat.nTWTSquare
			{
				if (!oBodyPr.upright) {
					if (!(oBodyPr.vert === AscFormat.nVertTTvert || oBodyPr.vert === AscFormat.nVertTTvert270 || oBodyPr.vert === AscFormat.nVertTTeaVert)) {
						oRet.w = w + TEXT_RECT_ERROR;
						oRet.h = h + TEXT_RECT_ERROR;
						oRet.correctW = l_ins + r_ins;
						oRet.correctH = t_ins + b_ins;
					} else {
						oRet.w = h + TEXT_RECT_ERROR;
						oRet.h = w + TEXT_RECT_ERROR;
						oRet.correctW = t_ins + b_ins;
						oRet.correctH = l_ins + r_ins;
					}
				} else {
					var _full_rotate = this.getFullRotate();
					if (checkNormalRotate(_full_rotate)) {
						if (!(oBodyPr.vert === AscFormat.nVertTTvert || oBodyPr.vert === AscFormat.nVertTTvert270 || oBodyPr.vert === AscFormat.nVertTTeaVert)) {
							oRet.w = w + TEXT_RECT_ERROR;
							oRet.h = h + TEXT_RECT_ERROR;
							oRet.correctW = l_ins + r_ins;
							oRet.correctH = t_ins + b_ins;
						} else {
							oRet.w = h + TEXT_RECT_ERROR;
							oRet.h = w + TEXT_RECT_ERROR;
							oRet.correctW = t_ins + b_ins;
							oRet.correctH = l_ins + r_ins;
						}
					} else {
						if (!(oBodyPr.vert === AscFormat.nVertTTvert || oBodyPr.vert === AscFormat.nVertTTvert270 || oBodyPr.vert === AscFormat.nVertTTeaVert)) {
							oRet.w = h + TEXT_RECT_ERROR;
							oRet.h = w + TEXT_RECT_ERROR;
							oRet.correctW = t_ins + b_ins;
							oRet.correctH = l_ins + r_ins;
						} else {
							oRet.w = w + TEXT_RECT_ERROR;
							oRet.h = h + TEXT_RECT_ERROR;
							oRet.correctW = l_ins + r_ins;
							oRet.correctH = t_ins + b_ins;
						}
					}
				}
				oRet.textRectW = oRet.w;
				oRet.textRectH = oRet.h;

				//oDocContent.Set_StartPage(0);
				/*oDocContent.Reset(0, 0, oRet.w, 20000);
        var CurPage = 0;
        var RecalcResult = recalcresult2_NextPage;
        while ( recalcresult2_End !== RecalcResult  )
            RecalcResult = oDocContent.Recalculate_Page( CurPage++, true );*/

				var oContentW = oRet.w;

				if (oForm && !oForm.IsMultiLineForm())
					oDocContent.SetUseXLimit(false);
				else
					oDocContent.SetUseXLimit(true);

				oDocContent.RecalculateContent(oContentW, oRet.h, nStartPage);
				oRet.contentH = oDocContent.GetSummaryHeight();

				if (this.bWordShape) {
					this.m_oSectPr = null;
					var oParaDrawing = getParaDrawing(this);
					if (oParaDrawing) {
						var oParentParagraph = oParaDrawing.Get_ParentParagraph();
						if (oParentParagraph) {
							var oSectPr = oParentParagraph.Get_SectPr();
							if (oSectPr) {
								this.m_oSectPr = new AscWord.SectPr();
								this.m_oSectPr.Copy(oSectPr);
							}
						}
					}
				}
			}
			
			if ((oDocContent && !oDocContent.bPresentation) && !this.isForm()) {
				
				let shift = 0;
				let drDoc = this.getDrawingDocument();
				if (drDoc) {
					shift = drDoc.GetMMPerDot(1);
				}
				
				let x = -l_ins - shift;
				let y = -t_ins - shift;
				
				let _w = oRect.r - oRect.l + 2 * shift;
				let _h = oRect.b - oRect.t + 2 * shift;
				
				if (this._isTextRotated(oBodyPr)) {
					oDocContent.Set_ClipInfo(0, y, y + _h, x, x + _w);
				} else {
					oDocContent.Set_ClipInfo(0, x, x + _w, y, y + _h);
				}
			}
			
			return oRet;
		};

		CShape.prototype.getSmartArtPointContent = function () {
			const smartartInfo = this.getSmartArtInfo();
			return smartartInfo && smartartInfo.contentPoint;
		}

		CShape.prototype.getSmartArtShapePoint = function () {
			return this.getSmartArtInfo() && this.getSmartArtInfo().shapePoint;
		}
		CShape.prototype.recalculateContent2 = function () {
			if (this.txBody) {
				if (this.isPlaceholder() || this.isPlaceholderInSmartArt()) {
					if (!this.isEmptyPlaceholder()) {
						return;
					}
					let aHierarchy = this.getHierarchy();
					for (let nPlaceholder = 0; nPlaceholder < aHierarchy.length; ++nPlaceholder) {
						let oHSp = aHierarchy[nPlaceholder];
						if (isRealObject(oHSp) && oHSp.hasCustomPrompt()) {
							if (oHSp.txBody && oHSp.txBody.content) {
								this.txBody.content2 = oHSp.txBody.content.Copy(this.txBody, this.getDrawingDocument(), {});
							}
						}
					}


					if (!this.txBody.content2) {
						var text;
						if (typeof AscCommonSlide !== "undefined" && AscCommonSlide.CNotes && this.parent instanceof AscCommonSlide.CNotes && this.nvSpPr.nvPr.ph.type === AscFormat.phType_body) {
							text = AscCommon.translateManager.getValue("Click to add notes");
						} else if (this.isObjectInSmartArt()) {
							const pointContent = this.getSmartArtPointContent();
							const point = pointContent && pointContent[0] && pointContent[0].point;
							if (point) {
								text = AscCommon.translateManager.getValue(point.prSet.phldrT || '');
							} else {
								text = '';
							}
						} else {
							text = this.getPlaceholderName();
						}
						this.txBody.content2 = AscFormat.CreateDocContentFromString(text, this.getDrawingDocument(), this.txBody);
						if (this.txBody.content && this.isObjectInSmartArt()) {
							var oContent = this.txBody.content;
							var oContent2 = this.txBody.content2;
							var contentLength = oContent.Content.length;
							var phldrParagraph = oContent2.Content[0];
							for (var i = 1; i < contentLength; i += 1) {
								var oCopy = phldrParagraph.Copy(oContent2, this.getDrawingDocument());
								oContent2.Internal_Content_Add(i, oCopy, false);
							}
						}
					} else {
						this.txBody.content2.Recalc_AllParagraphs_CompiledPr();
					}

					var content = this.txBody.content2;
					if (content) {
						var w, h;
						var l_ins, t_ins, r_ins, b_ins;
						var body_pr = this.getBodyPr();
						if (body_pr) {
							l_ins = AscFormat.isRealNumber(body_pr.lIns) ? body_pr.lIns : 2.54;
							r_ins = AscFormat.isRealNumber(body_pr.rIns) ? body_pr.rIns : 2.54;
							t_ins = AscFormat.isRealNumber(body_pr.tIns) ? body_pr.tIns : 1.27;
							b_ins = AscFormat.isRealNumber(body_pr.bIns) ? body_pr.bIns : 1.27;
						} else {
							l_ins = 2.54;
							r_ins = 2.54;
							t_ins = 1.27;
							b_ins = 1.27;
						}
						var rect = this.getTextRect && this.getTextRect();
						if (AscFormat.isRealNumber(rect.l) && AscFormat.isRealNumber(rect.t)
							&& AscFormat.isRealNumber(rect.r) && AscFormat.isRealNumber(rect.r)) {
							w = rect.r - rect.l - (l_ins + r_ins);
							h = rect.b - rect.t - (t_ins + b_ins);
						} else {
							w = this.extX - (l_ins + r_ins);
							h = this.extY - (t_ins + b_ins);
						}

						if (!body_pr.upright) {
							if (!(body_pr.vert === AscFormat.nVertTTvert || body_pr.vert === AscFormat.nVertTTvert270 || body_pr.vert === AscFormat.nVertTTeaVert)) {
								this.txBody.contentWidth2 = w;
								this.txBody.contentHeight2 = h;
							} else {
								this.txBody.contentWidth2 = h;
								this.txBody.contentHeight2 = w;
							}

						} else {
							var _full_rotate = this.getFullRotate();
							if (AscFormat.checkNormalRotate(_full_rotate)) {
								if (!(body_pr.vert === AscFormat.nVertTTvert || body_pr.vert === AscFormat.nVertTTvert270 || body_pr.vert === AscFormat.nVertTTeaVert)) {

									this.txBody.contentWidth2 = w;
									this.txBody.contentHeight2 = h;
								} else {
									this.txBody.contentWidth2 = h;
									this.txBody.contentHeight2 = w;
								}
							} else {
								if (!(body_pr.vert === AscFormat.nVertTTvert || body_pr.vert === AscFormat.nVertTTvert270 || body_pr.vert === AscFormat.nVertTTeaVert)) {

									this.txBody.contentWidth2 = h;
									this.txBody.contentHeight2 = w;
								} else {
									this.txBody.contentWidth2 = w;
									this.txBody.contentHeight2 = h;
								}
							}
						}


					}
					this.contentWidth2 = this.txBody.contentWidth2;
					this.contentHeight2 = this.txBody.contentHeight2;


					var content_ = this.getDocContent();
					if (content_) {
						for (i = 0; i < content.Content.length; i += 1) {
							if (content_.Content[i]) {
								content.Content[i].Pr = content_.Content[i].Pr.Copy();
								if (!content.Content[i].Pr.DefaultRunPr) {
									content.Content[i].Pr.DefaultRunPr = new AscCommonWord.CTextPr();
								}
								content.Content[i].Pr.DefaultRunPr.Merge(content_.Content[i].GetFirstRunPr());
							}
						}
					}
					this.bCheckAutoFitFlag = true;
					this.tmpFontScale = undefined;
					this.tmpLnSpcReduction = undefined;
					content.Set_StartPage(0);
					content.Reset(0, 0, w, 20000);
					content.RecalculateContent(this.txBody.contentWidth2, this.txBody.contentHeight2, 0);
					var oTextWarpContent = this.checkTextWarp(content, body_pr, this.txBody.contentWidth2, this.txBody.contentHeight2, false, true);
					this.txWarpStructParamarks2 = oTextWarpContent.oTxWarpStructParamarks;
					this.txWarpStruct2 = oTextWarpContent.oTxWarpStruct;
					this.bCheckAutoFitFlag = false;
				} else {
					this.txBody.content2 = null;
					this.txWarpStructParamarks2 = null;
					this.txWarpStruct2 = null;
				}
			} else {
				this.txWarpStructParamarks2 = null;
				this.txWarpStruct2 = null;
			}
		};

		CShape.prototype.isShape = function () {
			return true;
		};

		CShape.prototype.isInk = function () {
			const oGeometry = this.spPr && this.spPr.geometry;
			if(!oGeometry) {
				return false;
			}
			return oGeometry.isInk();
		};

		var aScales = [25000, 30000, 35000, 40000, 45000, 50000, 55000, 60000, 65000, 70000, 75000, 80000, 85000, 90000, 95000, 10000];


		CShape.prototype.recalculateContentWitCompiledPr = function () {
			var oContent = this.getDocContent && this.getDocContent();
			if (oContent) {
				oContent.Recalc_AllParagraphs_CompiledPr();
				this.recalcInfo.recalculateContent = true;
				if (this.isPlaceholderInSmartArt()) {
					this.recalcInfo.recalculateContent2 = true;
				}
				this.recalcInfo.recalculateTransformText = true;
				this.recalculate();
			}
		};

		CShape.prototype.getFirstFontSize = function () {
			let currentFontSize;
			if (this.txBody && this.txBody.content) {
				this.txBody.content.CheckRunContent(function (paraRun) {
					if (!currentFontSize) {
						currentFontSize = paraRun.Get_FontSize();
						return true;
					}
				});
				if (!currentFontSize) {
					this.txBody.content.Content.forEach(function (paragraph) {
						if (!currentFontSize) {
							currentFontSize = paragraph.TextPr.Value.FontSize;
							return true;
						}
					});
				}
			}
			return currentFontSize;
		}
		CShape.prototype.isCorrectSmartArtContentPoints = function () {
			const oContent = this.txBody && this.txBody.content;
			const contentPoints = this.getSmartArtPointContent();
			if (contentPoints && oContent) {
				let countPointParagraphs = 0;
				for (let i = 0; i < contentPoints.length; i++) {
					const node = contentPoints[i];
					const point = node.point;
					const oPointContent = point && point.t && point.t.content;
					if (oPointContent) {
						countPointParagraphs += oPointContent.Content.length;
					}
				}
				return oContent.Content.length === countPointParagraphs;
			}
			return false;
		};
		CShape.prototype.correctUngeneratedSmartArtContent = function () {
				const textAlgorithm = new AscFormat.TextAlgorithm();
				textAlgorithm.applyContentFilling(this);
		};
		CShape.prototype.setFontSizeInSmartArt = function (fontSize, bSkipRecalculateContent2, isParentWithChildren) {
			const oContent = this.txBody && this.txBody.content;
			if (this.txBody && oContent) {
				const currentFontSize = this.getFirstFontSize();
				const oBodyPr = this.txBody.getBodyPr();
				const pointContent = this.getSmartArtPointContent();
				if (oBodyPr && pointContent) {
					const paddings = {};
					const point = pointContent[0] && pointContent[0].point;
					if (point) {
						const isRecalculateInsets = point.isRecalculateInsets();
						const smartArt = this.group && this.group.group;
						if (smartArt && smartArt.isCanGenerateSmartArt()) {
							const shapeInfo = this.getSmartArtInfo();
							const marginFactors = shapeInfo.getMarginFactors();
							if (isRecalculateInsets.Top && marginFactors.tMarg !== undefined) {
								paddings.Top = g_dKoef_pt_to_mm * marginFactors.tMarg * fontSize;
							}
							if (isRecalculateInsets.Bottom && marginFactors.bMarg !== undefined) {
								paddings.Bottom = g_dKoef_pt_to_mm * marginFactors.bMarg * fontSize;
							}
							if (isRecalculateInsets.Left && marginFactors.lMarg !== undefined) {
								paddings.Left = g_dKoef_pt_to_mm * marginFactors.lMarg * fontSize;
							}
							if (isRecalculateInsets.Right && marginFactors.rMarg !== undefined) {
								paddings.Right = g_dKoef_pt_to_mm * marginFactors.rMarg * fontSize;
							}
						} else {
							if (isRecalculateInsets.Top) {
									const tInsetPerPt = oBodyPr.tIns / currentFontSize;
								paddings.Top = tInsetPerPt * fontSize;
							}
							if (isRecalculateInsets.Bottom) {
								const bInsetPerPt = oBodyPr.bIns / currentFontSize;
								paddings.Bottom = bInsetPerPt * fontSize;
							}
							if (isRecalculateInsets.Left) {
								const lInsetPerPt = oBodyPr.lIns / currentFontSize;
								paddings.Left = lInsetPerPt * fontSize;
							}
							if (isRecalculateInsets.Right) {
								const rInsetPerPt = oBodyPr.rIns / currentFontSize;
								paddings.Right = rInsetPerPt * fontSize;
							}
						}
					}
					// In files layout.xml insets depend on font size.
					// While there is no recalculation, we consider new insets as a dependency on the previous font size.
					this.setPaddings(paddings, {bNotCopyToPoints: true});
				}
				if (pointContent) {
					this.applySmartArtFontSize(fontSize, isParentWithChildren);
				} else {
					const bOldApplyToAll = oContent.ApplyToAll;
					oContent.ApplyToAll = true;
					oContent.AddToParagraph(new AscCommonWord.ParaTextPr({FontSize:fontSize}), false);
					oContent.ApplyToAll = bOldApplyToAll;
				}

				if (!bSkipRecalculateContent2) {
					this.recalculateContent2();
				}
			}
		};
		CShape.prototype.getFirstCustTFontSize = function () {
			const shapeInfo = this.getSmartArtInfo();
			const contentPoints = shapeInfo && shapeInfo.contentPoint;
			if (contentPoints) {
				let paragraphIndex = 0;
				for (let i = 0; i < contentPoints.length; i++) {
					const contentNode = contentPoints[i];
					const point = contentNode.point;
					const contentLength = point.t && point.t.content && point.t.content.Content.length;
					if (contentLength) {
						if (point && point.prSet && point.prSet.custT) {
							break;
						} else {
							paragraphIndex += contentLength;
						}
					}
				}
				const content = this.getDocContent();
				if (content) {
					const item = content.Content[paragraphIndex];
					if (item) {
						return item.Get_FirstTextPr2().FontSize;
					}
				}
			}
		};
		CShape.prototype.applyCustTSettings = function () {
			const fontSize = this.getFirstCustTFontSize();
			const oContent = this.getDocContent();
			if (AscFormat.isRealNumber(fontSize) && oContent) {
				this.applySmartArtPaddings(fontSize);
				this.applyCustTFontSizeSettings();
			}
		};

		CShape.prototype.applyCustTFontSizeSettings = function () {
			const contentPoints = this.getSmartArtPointContent();
			if (!contentPoints) {
				return;
			}
			const oContent = this.txBody && this.txBody.content;
			const shapeInfo = this.getSmartArtInfo();
			const nBulletParagraphIndex = this.getFirstBulletParagraphIndex();
			const bulletSpacingScale = shapeInfo.getChildrenSpacingScale();
			const paragraphSpacingScale = shapeInfo.getParentSpacingScale();

			if (oContent && contentPoints && contentPoints.length) {
				let startDepth;
				let paragraphIndex = 0;
				for (let i = 0; i < contentPoints.length; i++) {
					const node = contentPoints[i];
					const point = node.point;
					const pointContent = point.t && point.t.content;
					if (paragraphIndex === nBulletParagraphIndex) {
						startDepth = node.depth;
					}
					const deltaDepth = startDepth !== undefined ? node.depth - startDepth + 1 : 0;
					for (let j = 0; j < pointContent.Content.length; j += 1) {
						const oItem = oContent.Content[paragraphIndex];
						const fontSize = oItem.Get_FirstTextPr2().FontSize;
						if (startDepth !== undefined) {
							const indent = getSmartArtParagraphIndent(fontSize);
							oItem.Set_Spacing({After: fontSize * bulletSpacingScale}, false);
							oItem.Set_Ind({Left: deltaDepth * indent, FirstLine: -indent}, false);
						} else {
							oItem.Set_Spacing({After: fontSize * paragraphSpacingScale}, false);
							oItem.Set_Ind({Left: 0, FirstLine: 0}, false);
						}
						paragraphIndex += 1;
					}
				}
			}
		};
		CShape.prototype.applySmartArtPaddings = function (fontSize) {
			const oContent = this.txBody && this.txBody.content;
			if (this.txBody && oContent) {
				const oBodyPr = this.txBody.getBodyPr();
				const pointContent = this.getSmartArtPointContent();
				if (oBodyPr && pointContent) {
					const paddings = {};
					const point = pointContent[0] && pointContent[0].point;
					if (point) {
						const isRecalculateInsets = point.isRecalculateInsets();
						const shapeInfo = this.getSmartArtInfo();
						const marginFactors = shapeInfo.getMarginFactors();
						if (isRecalculateInsets.Top && marginFactors.tMarg !== undefined) {
							paddings.Top = g_dKoef_pt_to_mm * marginFactors.tMarg * fontSize;
						}
						if (isRecalculateInsets.Bottom && marginFactors.bMarg !== undefined) {
							paddings.Bottom = g_dKoef_pt_to_mm * marginFactors.bMarg * fontSize;
						}
						if (isRecalculateInsets.Left && marginFactors.lMarg !== undefined) {
							paddings.Left = g_dKoef_pt_to_mm * marginFactors.lMarg * fontSize;
						}
						if (isRecalculateInsets.Right && marginFactors.rMarg !== undefined) {
							paddings.Right = g_dKoef_pt_to_mm * marginFactors.rMarg * fontSize;
						}
					}

					this.setPaddings(paddings, {bNotCopyToPoints: true});
				}
			}
		}
		CShape.prototype.applySmartArtFontSize = function (fontSize, isParentWithChildren) {
			const contentPoints = this.getSmartArtPointContent();
			if (!contentPoints) {
				return;
			}
			const oContent = this.txBody && this.txBody.content;
			const shapeInfo = this.getSmartArtInfo();
			const nBulletParagraphIndex = this.getFirstBulletParagraphIndex();
			const mainParaTextPr = new AscCommonWord.ParaTextPr({FontSize: fontSize});
			let bulletTextPr = mainParaTextPr;
			if (isParentWithChildren) {
				const fontSizeScale = shapeInfo.getSecondaryFontSizeCoefficient();
				bulletTextPr = new AscCommonWord.ParaTextPr({FontSize: Math.round(fontSize * fontSizeScale)});
			}
			const bulletFontSize = bulletTextPr.Value.FontSize;
			const indent = getSmartArtParagraphIndent(bulletFontSize);
			const bulletSpacingScale = shapeInfo.getChildrenSpacingScale();
			const paragraphSpacingScale = shapeInfo.getParentSpacingScale();

			if (oContent && contentPoints && contentPoints.length) {
				let startDepth;
				let paragraphIndex = 0;
				let firstLine = 0;
				for (let i = 0; i < contentPoints.length; i++) {
					const node = contentPoints[i];
					const point = node.point;
					const pointContent = point.t && point.t.content;
					if (paragraphIndex === nBulletParagraphIndex) {
						startDepth = node.depth;
						firstLine = -indent;
					}
					const deltaDepth = startDepth !== undefined ? node.depth - startDepth + 1 : 0;
					for (let j = 0; j < pointContent.Content.length; j += 1) {
						const oItem = oContent.Content[paragraphIndex];
						oItem.SetApplyToAll(true);
						if (startDepth !== undefined) {
							oItem.AddToParagraph(bulletTextPr, false);
							oItem.Set_Spacing({After: bulletFontSize * bulletSpacingScale}, false);
						} else {
							oItem.AddToParagraph(mainParaTextPr, false);
							oItem.Set_Spacing({After: fontSize * paragraphSpacingScale}, false);
						}
						oItem.Set_Ind({Left: deltaDepth * indent, FirstLine: firstLine}, false);
						oItem.SetApplyToAll(false);
						paragraphIndex += 1;
					}
				}
			}
		};
		CShape.prototype.resetSmartArtMaxFontSize = function () {
			const oSmartArtInfo = this.getSmartArtInfo();
			if (oSmartArtInfo) {
				delete oSmartArtInfo.maxFontSize;
			}
		};
		CShape.prototype.correctSmartArtUndo = function () {
			if (this.isObjectInSmartArt()) {
				this.group.group.fitFontSize();
				const oSmartArtInfo = this.getSmartArtInfo();
				if (oSmartArtInfo) {
					if (!this.isEmptyPlaceholder(true)) {
						if (this.isPlaceholderInSmartArt()) {
							const oContent = this.getDocContent && this.getDocContent();
							const arrPointContent = this.getSmartArtPointContent();
							const bIsNotEmptyShape = oContent.Content.some(function (paragraph) {
								return !paragraph.Is_Empty({SkipEnd: true, SkipPlcHldr: false});
							});
							if (bIsNotEmptyShape) {
								arrPointContent.forEach(function (node) {
									const point = node.point;
									point.prSet.setPhldr(false);
								})
								this.txBody.content2 = null;
							}
						}
					}
				}
			}

		};

		CShape.prototype.getInsets = function (properties) {;
			properties = properties || {};
			const oBodyPr = properties.bodyPr || this.getBodyPr && this.getBodyPr()
			let lIns = 0, tIns = 0, rIns = 0, bIns = 0;
			if (!properties.bIgnoreInsets) {
				if(oBodyPr) {
					lIns = (AscFormat.isRealNumber(oBodyPr.lIns) ? oBodyPr.lIns : 2.54);
					tIns = (AscFormat.isRealNumber(oBodyPr.tIns) ? oBodyPr.tIns : 1.27);
					rIns = (AscFormat.isRealNumber(oBodyPr.rIns) ? oBodyPr.rIns : 2.54);
					bIns = (AscFormat.isRealNumber(oBodyPr.bIns) ? oBodyPr.bIns : 1.27);
				}
				else {
					lIns = 2.54;
					tIns = 1.27;
					rIns = 2.54;
					bIns = 1.27;
				}
			}

			if (this.bWordShape) {
				const oPen = this.pen;
				if (oPen) {
					let penW = (oPen.w == null) ? 12700 : parseInt(oPen.w);
					penW /= 36000;
					switch (oPen.algn) {
						case 1: {
							break;
						}
						default: {
							penW /= 2;
							break;
						}
					}
					lIns += penW;
					rIns += penW;
					tIns += penW;
					bIns += penW;
				}
			}

			const oForm = this.isForm && this.isForm() ? this.getInnerForm() : null;
			if (oForm) {
				const nFormHorPadding = this.getFormHorPadding();
				lIns = nFormHorPadding;
				rIns = nFormHorPadding;
				tIns = 0;
				bIns = 0;
			}
			return {
				lIns: lIns,
				tIns: tIns,
				rIns: rIns,
				bIns: bIns
			};
		};

		CShape.prototype.getTextRectBoundsWithInsets = function (properties) {
			properties = properties || {};
			const result = {l: 0, t: 0, r: 0, b: 0};
			const oBodyPr = properties.bodyPr || this.getBodyPr && this.getBodyPr();
			if (oBodyPr) {
				const insets = this.getInsets(properties);
				const oRect = this.getTextRect();

				let _l = oRect.l + insets.lIns;
				let _t = oRect.t + insets.tIns;
				let _r = oRect.r - insets.rIns;
				let _b = oRect.b - insets.bIns;

				if (_l >= _r) {
					const _c = (_l + _r) * 0.5;
					_l = _c - 0.01;
					_r = _c + 0.01;
				}

				if (_t >= _b) {
					const _c = (_t + _b) * 0.5;
					_t = _c - 0.01;
					_b = _c + 0.01;
				}

				result.r = _r;
				result.l = _l;
				result.t = _t;
				result.b = _b;
			}
			return result;
		};

		CShape.prototype.getTextRectContentHW = function (properties) {
			const bounds = this.getTextRectBoundsWithInsets(properties);
			return {
				height: bounds.b - bounds.t,
				width: bounds.r - bounds.l
			};
		};

		CShape.prototype.compareHeightOfBoundsTextInSmartArt = function () {
			const sizesOfTextRectContent = this.getTextRectContentHW();
			const vert = this.txBody && this.txBody.bodyPr.vert;


			let nContentHeight;
			if (this.txBody && this.txBody.content2) {
				this.recalculateContent();
				nContentHeight = this.contentHeight;
			} else {
				this.recalculateContent();
				nContentHeight = this.contentHeight;
			}
			if (vert === AscFormat.nVertTTvert270 || vert === AscFormat.nVertTTvert || vert === AscFormat.nVertTTeaVert) {
				return nContentHeight >= sizesOfTextRectContent.width;
			}
			return nContentHeight >= sizesOfTextRectContent.height;
		};
		CShape.prototype.compareWidthOfBoundsTextInSmartArt = function (bMax) {
			const oContent = this.getCurrentDocContentInSmartArt();
			const sizesOfTextRectContent = this.getTextRectContentHW();
			const vert = this.txBody && this.txBody.bodyPr.vert;
			let widthOfContent = oContent.RecalculateMinMaxContentWidth();
			if (bMax) {
				widthOfContent = widthOfContent.Max;
			} else {
				widthOfContent = widthOfContent.Min;
			}
			if (vert === AscFormat.nVertTTvert270 || vert === AscFormat.nVertTTvert || vert === AscFormat.nVertTTeaVert) {
				return widthOfContent > sizesOfTextRectContent.height;
			}
			return widthOfContent > sizesOfTextRectContent.width;
		};
		CShape.prototype.checkFitContentForSmartArt = function () {
			// почему-то у майков не подбирается шрифт для ширины, если вставлено только уравнение
			const oContent = this.getCurrentDocContentInSmartArt();
			if (oContent) {
				for (let i = 0; i < oContent.Content.length; i += 1) {
					const oParagraph = oContent.Content[i];
					for (let j = 0; j < oParagraph.Content.length; j += 1) {
						const oElement = oParagraph.Content[j];
						if (oElement.Type !== para_Math && !oElement.Is_Empty({SkipEnd: true})) {
							return true;
						}
					}
				}
			}
			return false;
		};
		CShape.prototype.getFirstBulletParagraphIndex = function () {
			const oContent = this.getDocContent();
			for (let i = 0; i < oContent.Content.length; i++) {
				const shapeParagraph = oContent.Content[i];
				if (shapeParagraph.Pr.Bullet && shapeParagraph.Pr.Bullet.bulletType.type === AscFormat.BULLET_TYPE_BULLET_CHAR) {
					return i;
				}
			}
			return -1;
		};
		CShape.prototype.findFitFontSize = function (nMinFontSize, nMaxFontSize, bMax, isParentWithChildren) {
			if (nMinFontSize > nMaxFontSize) {
				return null;
			}
			if (nMinFontSize === nMaxFontSize) {
				return nMaxFontSize;
			}
			if (nMinFontSize)
			return AscFormat.ExecuteNoHistory(function () {
				const MAX_FONT_SIZE = nMaxFontSize || 65;
				const content = this.getCurrentDocContentInSmartArt();
				if (content) {
					const nOldFontSize = this.getFirstFontSize();
					const scalesForSmartArt = Array(Math.max(1, Math.trunc(MAX_FONT_SIZE - (nMinFontSize - 1)))).fill(0).map(function (e, ind) {
						return ind + nMinFontSize;
					});
					let a = 0;
					let b = scalesForSmartArt.length - 1;
					let averageAmount = Math.floor((a + b) / 2);
					while (a !== averageAmount && b !== averageAmount) {
						this.setFontSizeInSmartArt(scalesForSmartArt[averageAmount], false, isParentWithChildren);
						let bCheck = this.compareWidthOfBoundsTextInSmartArt(bMax) || this.compareHeightOfBoundsTextInSmartArt();

						if (bCheck) {
							b = averageAmount;
						} else {
							a = averageAmount;
						}
						averageAmount = Math.floor((a + b) / 2);
					}
					this.setFontSizeInSmartArt(scalesForSmartArt[averageAmount + 1], false, isParentWithChildren);
					if (!this.compareWidthOfBoundsTextInSmartArt(bMax) && !this.compareHeightOfBoundsTextInSmartArt()) {
						averageAmount += 1;
					}
					this.setFontSizeInSmartArt(nOldFontSize, false, isParentWithChildren);
					this.recalculateContent();
					return scalesForSmartArt[averageAmount];
				}
				return MAX_FONT_SIZE;
			}, this, []);
		};
		CShape.prototype.findFitFontSizeForSmartArt = function (isParentWithChildren) {
			const oSmartArtInfo = this.getSmartArtInfo();

			const maxFontSize = oSmartArtInfo.getMaxConstrFontSize(oSmartArtInfo.getAdaptFontSizeInfo().contentFillingType === AscCommon.smartArtContentFillingType_onlyChildren);
			const minFontSize = oSmartArtInfo.getMinConstrFontSize();
			return this.findFitFontSize(minFontSize, maxFontSize, false, isParentWithChildren);
		};

		CShape.prototype.getShapesForFitText = function () {
			if (this.isObjectInSmartArt()) {
				if (this.group.group.isCanGenerateSmartArt()) {
					const smartArtInfo = this.getSmartArtInfo();
					return smartArtInfo.getAdaptFontSizeInfo();
				}
				//todo
				return {shapes: this.group.group.getShapesForFitText(this), contentFillingType: AscCommon.smartArtContentFillingType_onlyParent};
			}
			return [];
		};

		CShape.prototype.isCanFitFontSize = function () {
			const arrMainContentPoints = this.getSmartArtPointContent();
			if (!(arrMainContentPoints && arrMainContentPoints.length)) {
				return false;
			}
			return arrMainContentPoints.every(function (node) {
				const point = node.point;
				return point && point.prSet && !point.prSet.custT;
			});
		};

		function fitSmartArtShapes(arrShapes, isParentWithChildren) {
			const arrPlaceholders = [];
			const arrFitText = [];
			for (let i = 0; i < arrShapes.length; i += 1) {
				const oShape = arrShapes[i];
				var contentPoints = oShape.getSmartArtPointContent();
				if (!contentPoints) {
					continue;
				}
				const isNotPlaceholder = contentPoints.every(function (node) {
					const point = node.point;
					return point && point.prSet && !point.prSet.custT;
				}) && contentPoints.some(function (node) {
					const point = node.point;
					return point && point.prSet && !point.prSet.phldr;
				});
				if (isNotPlaceholder) {
					const oContent = oShape.getDocContent();
					if (oContent && !oContent.Is_Empty({SkipEnd: true, SkipPlcHldr: false})) {
						arrFitText.push(oShape);
					}
				} else {
					const isPlaceholder = contentPoints.every(function (node) {
						const point = node.point;
						return point && point.prSet && (typeof point.prSet.phldrT === "string") && !point.prSet.custT && point.prSet.phldr;
					});
					if (isPlaceholder) {
						arrPlaceholders.push(oShape);
					}
				}
			}

			let nFitFontSize = 65;
			for (let i = 0; i < arrFitText.length; i += 1) {
				const oShape = arrFitText[i];
				const oShapeSmartArtInfo = oShape.getSmartArtInfo();
				if (oShapeSmartArtInfo) {
					if (!AscFormat.isRealNumber(oShapeSmartArtInfo.maxFontSize)) {
						oShapeSmartArtInfo.setMaxFontSize(oShape.findFitFontSizeForSmartArt(isParentWithChildren));
					}
					if (oShapeSmartArtInfo.maxFontSize < nFitFontSize) {
						nFitFontSize = oShapeSmartArtInfo.maxFontSize;
					}
				}
			}
			const adaptRelationArrays = [];
			for (let i = 0; i < arrFitText.length; i += 1) {
				const oShape = arrFitText[i];
				const nCurrentFontSize = oShape.getFirstFontSize();
				const smartArtInfo = oShape.getSmartArtInfo();
				if (nCurrentFontSize !== nFitFontSize) {
					oShape.setFontSizeInSmartArt(nFitFontSize, true, isParentWithChildren);
				} else {
					oShape.recalculate();
				}

				smartArtInfo.collectTextConstraintRelations(adaptRelationArrays);
			}

			for (let i = 0; i < adaptRelationArrays.length; i += 1) {
				const presNodeArray = adaptRelationArrays[i];
				if (presNodeArray.length) {
					const editorShape = presNodeArray[0].contentNodes[0] && presNodeArray[0].contentNodes[0].getContentNode().getShape().editorShape;
					if (editorShape) {
						const smartArtInfo = editorShape.getSmartArtInfo();
						if (AscFormat.isRealNumber(smartArtInfo.maxFontSize)) {
							editorShape.setTruthFontSizeInSmartArt(true);
						}
					}
				}
			}

			for (let i = 0; i < arrPlaceholders.length; i += 1) {
				const oShape = arrPlaceholders[i];
				const nCurrentFontSize = oShape.getFirstFontSize();
				const oPlaceholderSmartArtInfo = oShape.getSmartArtInfo();
				if (oPlaceholderSmartArtInfo) {
					if (!AscFormat.isRealNumber(oPlaceholderSmartArtInfo.maxFontSize)) {
						oPlaceholderSmartArtInfo.setMaxFontSize(oShape.findFitFontSizeForSmartArt(isParentWithChildren));
					}
					const nPlaceholderFontSize = Math.min(oPlaceholderSmartArtInfo.maxFontSize, nFitFontSize);
					if (nCurrentFontSize !== nPlaceholderFontSize) {
						oShape.setFontSizeInSmartArt(nPlaceholderFontSize, true, isParentWithChildren);
					} else {
						oShape.recalculate();
					}
				} else if (nCurrentFontSize !== nFitFontSize) {
					oShape.setFontSizeInSmartArt(nFitFontSize, true, isParentWithChildren);
				} else {
					oShape.recalculate();
				}
			}
		}
		CShape.prototype.setTruthFontSizeInSmartArt = function (updateAllMaxFontSize) {
			let arrShapes;
			if (updateAllMaxFontSize) {
				arrShapes = this.getShapesForFitText();
				for (let i = 0; i < arrShapes.shapes.length; i += 1) {
					const shape = arrShapes.shapes[i];
					const oSmartArtInfo = shape.getSmartArtInfo();
					if (oSmartArtInfo) {
						oSmartArtInfo.setMaxFontSize(null);
					}
				}
			} else {
				if (!this.isCanFitFontSize()) {
					return;
				}
				arrShapes = this.getShapesForFitText();
				const oSmartArtInfo = this.getSmartArtInfo();
				if (oSmartArtInfo) {
					oSmartArtInfo.setMaxFontSize(null);
				}
			}

			fitSmartArtShapes(arrShapes.shapes, arrShapes.contentFillingType === AscCommon.smartArtContentFillingType_parentWithChildren);
		};

		CShape.prototype.checkExtentsByDocContent = function (bForce, bNeedRecalc) {
			if ((!this.bWordShape || this.group || bForce) && this.checkAutofit(true)) {
				var oMainGroup = this.getMainGroup();
				if (oMainGroup && !(bNeedRecalc === false)) {
					oMainGroup.normalize();
				}

				this.tmpFontScale = undefined;
				this.tmpLnSpcReduction = undefined;
				this.bCheckAutoFitFlag = true;
				var oOldRecalcTitle = this.recalcInfo.recalcTitle;
				var bOldRecalcTitle = this.recalcInfo.bRecalculatedTitle;
				this.handleUpdateExtents();
				this.recalcInfo.bRecalculatedTitle = false;
				this.recalcInfo.recalcTitle = this;
				this.recalculate();
				this.bCheckAutoFitFlag = false;
				this.recalcInfo.recalcTitle = oOldRecalcTitle;
				this.recalcInfo.bRecalculatedTitle = bOldRecalcTitle;
				AscFormat.CheckSpPrXfrm(this, true);
				this.spPr.xfrm.setExtX(this.extX + TEXT_RECT_ERROR);
				this.spPr.xfrm.setExtY(this.extY + TEXT_RECT_ERROR);
				if (!this.bWordShape || this.group) {
					this.spPr.xfrm.setOffX(this.x);
					this.spPr.xfrm.setOffY(this.y);
					if (this.drawingBase) {
						CheckExcelDrawingXfrm(this.spPr.xfrm);
					}
				}
				if (!(bNeedRecalc === false)) {
					if (oMainGroup) {
						oMainGroup.updateCoordinatesAfterInternalResize();
						if (oMainGroup.parent && oMainGroup.parent.CheckWH) {
							oMainGroup.parent.CheckWH();
							if (this.bWordShape) {
								editor.WordControl.m_oLogicDocument.Recalculate();
							}
						}
					} else {
						this.checkDrawingBaseCoords();
					}
				}
				return true;
			} else {
				var oBodyPr = this.getBodyPr && this.getBodyPr();
				var oContent = this.getDocContent && this.getDocContent();
				if (oBodyPr && oContent && this.clipRect) {
					var oTextFit = oBodyPr.textFit;
					if (oTextFit && oTextFit.type === AscFormat.text_fit_NormAuto) {
						var dOldContentHeight = this.contentHeight;
						var dOldClipW = this.clipRect.w;
						var dOldClipH = this.clipRect.h;
						this.recalcInfo.recalculateContent = true;
						this.recalculate();
						if (!AscFormat.isRealNumber(oTextFit.fontScale) && !AscFormat.isRealNumber(oTextFit.lnSpcReduction)
							&& this.contentHeight <= this.clipRect.h) {
							return;
						}
						if (!bForce && AscFormat.isRealNumber(dOldClipW) && AscFormat.isRealNumber(dOldClipH)
							&& AscFormat.fApproxEqual(dOldClipW, this.clipRect.w) && AscFormat.fApproxEqual(dOldClipH, this.clipRect.h)) {
							if (AscFormat.isRealNumber(dOldContentHeight) && AscFormat.fApproxEqual(dOldContentHeight, this.contentHeight)) {
								return;
							}
							if (dOldContentHeight < this.contentHeight && oTextFit.fontScale === aScales[0]) {
								return;
							}
						}

						this.bCheckAutoFitFlag = true;

						this.tmpFontScale = undefined;
						this.tmpLnSpcReduction = undefined;
						this.recalculateContentWitCompiledPr();
						if (this.contentHeight <= this.clipRect.h) {
							oBodyPr = oBodyPr.createDuplicate();
							oBodyPr.textFit.lnSpcReduction = this.tmpLnSpcReduction;
							oBodyPr.textFit.fontScale = this.tmpFontScale;
							if (this.bWordShape) {
								this.setBodyPr(oBodyPr);
							} else {
								if (this.txBody) {
									this.txBody.setBodyPr(oBodyPr);
								}
							}
							this.bCheckAutoFitFlag = false;
							this.tmpFontScale = undefined;
							this.tmpLnSpcReduction = undefined;
							return;
						}


						var dReductionScale = 0.2;

						var nCurIndex = aScales.length - 1;
						var nCurShift = -((aScales.length) / 2);
						while (true) {
							nCurIndex += nCurShift;
							if (nCurIndex - 1 >= 0) {
								this.tmpFontScale = aScales[nCurIndex - 1];
								this.tmpLnSpcReduction = dReductionScale * (100000 - this.tmpFontScale) >> 0;
								this.recalculateContentWitCompiledPr();


								if (this.contentHeight <= this.clipRect.h) {
									this.tmpFontScale = aScales[nCurIndex];
									this.tmpLnSpcReduction = dReductionScale * (100000 - this.tmpFontScale) >> 0;
									this.recalculateContentWitCompiledPr();
									if (this.contentHeight >= this.clipRect.h) {
										this.tmpFontScale = aScales[nCurIndex - 1];
										this.tmpLnSpcReduction = dReductionScale * (100000 - this.tmpFontScale) >> 0;
										break;
									} else {
										nCurShift = Math.abs(nCurShift) / 2;
									}
								} else {
									nCurShift = -Math.abs(nCurShift) / 2;
								}
								if (Math.abs(nCurShift) < 1) {
									break;
								}
							} else {
								this.tmpFontScale = aScales[0];
								this.tmpLnSpcReduction = dReductionScale * (100000 - this.tmpFontScale) >> 0;
								break;
							}
						}
						if (AscFormat.isRealNumber(this.tmpFontScale) && this.tmpFontScale < 90000) {
							if (this.isPlaceholder()) {
								var nType = this.getPlaceholderType();
								if (nType === AscFormat.phType_title || nType === AscFormat.phType_ctrTitle) {
									this.tmpFontScale = 90000;
									this.tmpLnSpcReduction = dReductionScale * (100000 - this.tmpFontScale) >> 0;
								}
							}
						}

						if (oBodyPr.textFit.lnSpcReduction !== this.tmpLnSpcReduction
							|| oBodyPr.textFit.fontScale !== this.tmpFontScale) {
							oBodyPr = oBodyPr.createDuplicate();
							oBodyPr.textFit.lnSpcReduction = this.tmpLnSpcReduction;
							oBodyPr.textFit.fontScale = this.tmpFontScale;
							if (this.bWordShape) {
								this.setBodyPr(oBodyPr);
							} else {
								if (this.txBody) {
									this.txBody.setBodyPr(oBodyPr);
								}
							}
						}
						this.bCheckAutoFitFlag = false;
						this.tmpFontScale = undefined;
						this.tmpLnSpcReduction = undefined;
						this.recalculateContentWitCompiledPr();
					} else {
						var oForm;
						if (this.isForm && this.isForm() && (oForm = this.getInnerForm()) && oForm.IsAutoFitContent() && oForm.GetLogicDocument() && oForm.GetLogicDocument().CheckFormAutoFit)
							oForm.GetLogicDocument().CheckFormAutoFit(oForm);

						if (bForce) {
							this.recalculateContentWitCompiledPr();
						}
					}
					if (this.isPlaceholderInSmartArt()) {
						var isNotEmptyShape = oContent.Content.some(function (paragraph) {
							return !paragraph.Is_Empty({SkipEnd: true, SkipPlcHldr: false});
						});
						const pointContent = this.getSmartArtPointContent();
						if (isNotEmptyShape && pointContent) {
							pointContent.forEach(function (node) {
								const point = node.point;
								point.prSet.setPhldr(false);
							})
							this.txBody.content2 = null;
						}
					}
					if (this.isObjectInSmartArt()) {
						this.copyTextInfoFromShapeToPoint();
						this.setTruthFontSizeInSmartArt();
					}
				}
			}
			return false;
		};


		CShape.prototype.getTransformMatrix = function () {
			return this.transform;
		};

		CShape.prototype.getTransform = function () {

			return {
				x: this.x,
				y: this.y,
				extX: this.extX,
				extY: this.extY,
				rot: this.rot,
				flipH: this.flipH,
				flipV: this.flipV
			};
		};

		CShape.prototype.getAngle = function (x, y) {
			var px = this.invertTransform.TransformPointX(x, y);
			var py = this.invertTransform.TransformPointY(x, y);
			return Math.PI * 0.5 + Math.atan2(px - this.extX * 0.5, py - this.extY * 0.5);
		};

		CShape.prototype.drawAdjustments = function (drawingDocument) {
			if (this.spPr && isRealObject(this.spPr.geometry) && this.canChangeAdjustments()) {
				this.spPr.geometry.drawAdjustments(drawingDocument, this.transform, false);
			}
			if (this.recalcInfo.warpGeometry) {
				this.recalcInfo.warpGeometry.drawAdjustments(drawingDocument, this.transformTextWordArt, true);
			}
		};

		CShape.prototype.getHandlePosByIndex = function (numHandle) {
			var t = this.transform;
			switch (numHandle) {
				case 0:
					return {x: t.TransformPointX(0, 0), y: t.TransformPointY(0, 0)};
				case 1:
					return {x: t.TransformPointX(this.extX / 2.0, 0), y: t.TransformPointY(this.extX / 2.0, 0)};
				case 2:
					return {x: t.TransformPointX(this.extX, 0), y: t.TransformPointY(this.extX, 0)};
				case 3:
					return {
						x: t.TransformPointX(this.extX, this.extY / 2.0),
						y: t.TransformPointY(this.extX, this.extY / 2.0)
					};
				case 4:
					return {x: t.TransformPointX(this.extX, this.extY), y: t.TransformPointY(this.extX, this.extY)};
				case 5:
					return {
						x: t.TransformPointX(this.extX / 2.0, this.extY),
						y: t.TransformPointY(this.extX / 2.0, this.extY)
					};
				case 6:
					return {x: t.TransformPointX(0, this.extY), y: t.TransformPointY(0, this.extY)};
				case 7:
					return {x: t.TransformPointX(0, this.extY / 2.0), y: t.TransformPointY(0, 0)};
				default:
			}
		};


		CShape.prototype.getGroupHierarchy = function () {
			if (this.recalcInfo.recalculateGroupHierarchy) {
				this.groupHierarchy = [];
				if (isRealObject(this.group)) {
					var parent_group_hierarchy = this.group.getGroupHierarchy();
					for (var i = 0; i < parent_group_hierarchy.length; ++i) {
						this.groupHierarchy.push(parent_group_hierarchy[i]);
					}
					this.groupHierarchy.push(this.group);
				}
				this.recalcInfo.recalculateGroupHierarchy = false;
			}
			return this.groupHierarchy;
		};


		CShape.prototype.hitInTextRectWord = function (x, y) {
			if (!AscFormat.canSelectDrawing(this)) {
				return false;
			}
			var content = this.getDocContent && this.getDocContent();
			if (content) {
				var w, h, x_, y_;
				if (this.isObjectInSmartArt() && this.invertTransformText) {
					x_ = 0;
					y_ = 0;
					w = this.contentWidth;
					h = this.contentHeight;
					return AscFormat.HitToRect(x, y, this.invertTransformText, x_, y_, w, h);
				} else if (this.invertTransform) {
					var rect = this.getTextRect && this.getTextRect();
					if (rect && AscFormat.isRealNumber(rect.l) && AscFormat.isRealNumber(rect.t)
						&& AscFormat.isRealNumber(rect.r) && AscFormat.isRealNumber(rect.r)) {
						x_ = rect.l;
						y_ = rect.t;
						w = rect.r - rect.l;
						h = rect.b - rect.t;
					} else {
						x_ = 0;
						y_ = 0;
						w = this.extX;
						h = this.extY;
					}
					return AscFormat.HitToRect(x, y, this.invertTransform, x_, y_, w, h);
				}
			}
			return false;
		};


		CShape.prototype.hitInTextRect = function (x, y) {
			var oController = this.getDrawingObjectsController && this.getDrawingObjectsController();
			if (this.parent && this.parent.kind === AscFormat.TYPE_KIND.NOTES) {
				return true;
			}


			if (this.checkHiddenInAnimation && this.checkHiddenInAnimation()) {
				return false;
			}
			if (!AscFormat.canSelectDrawing(this)) {
				return false;
			}

			var bForceWord = ((this.isEmptyPlaceholder && this.isEmptyPlaceholder()) || (this.isPlaceholder && this.isPlaceholder() && oController && (AscFormat.getTargetTextObject(oController) === this)));
			if (bForceWord) {
				if (this.hitInTextRectWord(x, y)) {
					return true;
				}
			}
			if (!this.txWarpStruct || !this.recalcInfo.warpGeometry ||
				this.recalcInfo.warpGeometry.preset === "textNoShape" ||
				oController && (AscFormat.getTargetTextObject(oController) === this || (oController.curState.startTargetTextObject === this))) {
				var content = this.getDocContent && this.getDocContent();
				if (content && this.invertTransformText) {
					return AscFormat.HitToRect(x, y, this.invertTransformText, 0, 0, this.contentWidth, this.contentHeight);
				}
			} else {
				return this.hitInTextRectWord(x, y);
			}

			return false;
		};


		CShape.prototype.updateCursorType = function (x, y, e) {
			if (this.invertTransformText) {
				var tx = this.invertTransformText.TransformPointX(x, y);
				var ty = this.invertTransformText.TransformPointY(x, y);
				this.txBody.content.UpdateCursorType(tx, ty, 0);
			}
		};

		CShape.prototype.selectionSetStart = function (e, x, y, slideIndex) {
			if (this.isProtectedText && this.isProtectedText()) {
				return;
			}
			var content = this.getDocContent();
			if (isRealObject(content)) {
				var tx, ty;
				tx = this.invertTransformText.TransformPointX(x, y);
				ty = this.invertTransformText.TransformPointY(x, y);
				if (e.Button === AscCommon.g_mouse_button_right) {
					if (content.CheckPosInSelection(tx, ty, 0)) {
						this.rightButtonFlag = true;
						return;
					}
				}
				if (!(/*content.IsTextSelectionUse() && */e.ShiftKey))
					content.Selection_SetStart(tx, ty, slideIndex - content.GetRelativeStartPage(), e);
				else {
					if (!content.IsTextSelectionUse()) {
						content.StartSelectionFromCurPos();
					}
					content.Selection_SetEnd(tx, ty, slideIndex - content.GetRelativeStartPage(), e);
				}
			}
		};

		CShape.prototype.selectionSetEnd = function (e, x, y, slideIndex) {
			if (this.isProtectedText && this.isProtectedText()) {
				return;
			}
			var content = this.getDocContent();
			if (isRealObject(content)) {
				var tx, ty;
				tx = this.invertTransformText.TransformPointX(x, y);
				ty = this.invertTransformText.TransformPointY(x, y);
				if (!(e.Type === AscCommon.g_mouse_event_type_up && this.rightButtonFlag)) {
					content.Selection_SetEnd(tx, ty, slideIndex - content.GetRelativeStartPage(), e);
				}
			}
			delete this.rightButtonFlag;
		};

		CShape.prototype.Get_Theme = function () {
			return this.getParentObjects().theme;
		};

		CShape.prototype.updateSelectionState = function () {
			if (Asc.editor.isPdfEditor()) {
				return AscPDF.CPdfShape.prototype.updateSelectionState.call(this);
			}
			
			var drawing_document = this.getDrawingDocument();
			if (drawing_document) {
				var content = this.getDocContent();
				if (content) {
					var oLogicDocument = content.GetLogicDocument ? content.GetLogicDocument() : null;

					var oMatrix = null;
					if (this.transformText) {
						oMatrix = this.transformText.CreateDublicate();
					}
					drawing_document.UpdateTargetTransform(oMatrix);
					if (true === content.IsSelectionUse()) {
						// Выделение нумерации
						if (selectionflag_Numbering == content.Selection.Flag) {
							drawing_document.TargetEnd();
							drawing_document.SelectEnabled(true);
							drawing_document.SelectClear();
							drawing_document.SelectShow();
						}
						// Обрабатываем движение границы у таблиц
						else if (null != content.Selection.Data && true === content.Selection.Data.TableBorder && type_Table == content.Content[content.Selection.Data.Pos].GetType()) {
							// Убираем курсор, если он был
							drawing_document.TargetEnd();
						} else {
							if (false === content.IsSelectionEmpty()) {
								drawing_document.TargetEnd();
								drawing_document.SelectEnabled(true);
								drawing_document.SelectClear();
								drawing_document.SelectShow();
							} else {
								if (true !== content.Selection.Start) {
									content.RemoveSelection();
								}
								drawing_document.SelectEnabled(false);
								content.RecalculateCurPos();

								drawing_document.TargetStart();
								drawing_document.TargetShow();

								if (oLogicDocument && oLogicDocument.IsFillingFormMode && oLogicDocument.IsFillingFormMode()) {
									var oContentControl = oLogicDocument.GetContentControl();
									if (oContentControl && oContentControl.IsCheckBox())
										drawing_document.TargetEnd();
								}
							}
						}
					} else {
						drawing_document.SelectEnabled(false);
						content.RecalculateCurPos();

						drawing_document.TargetStart();
						drawing_document.TargetShow();

						if (oLogicDocument && oLogicDocument.IsFillingFormMode && oLogicDocument.IsFillingFormMode()) {
							var oContentControl = oLogicDocument.GetContentControl();
							if (oContentControl && oContentControl.IsCheckBox())
								drawing_document.TargetEnd();
						}
					}
				} else {
					drawing_document.UpdateTargetTransform(new CMatrix());
					drawing_document.TargetEnd();
					drawing_document.SelectEnabled(false);
					drawing_document.SelectClear();
					drawing_document.SelectShow();
				}
			}
		};

		CShape.prototype.check_bounds = function (checker) {
			if (this.spPr && this.spPr.geometry) {
				this.spPr.geometry.check_bounds(checker);
			} else {
				checker._s();
				checker._m(0, 0);
				checker._l(this.extX, 0);
				checker._l(this.extX, this.extY);
				checker._l(0, this.extY);
				checker._z();
				checker._e();
			}
		};


		CShape.prototype.haveSelectedDrawingInContent = function () {
			if (this.bWordShape) {
				var aAllDrawings = this.recalcInfo.AllDrawings;
				for (var i = 0; i < aAllDrawings.length; ++i) {
					if (aAllDrawings[i] && aAllDrawings[i].GraphicObj && aAllDrawings[i].GraphicObj.selected) {
						return true;
					}
				}
			}
			return false;
		};


		CShape.prototype.clipTextRect = function (graphics, transform, transformText, pageIndex) {
			if (this.clipRect) {
				var transform_ = transform ? transform : this.transform;
				var transformText_ = transformText ? transformText : this.transformText;
				var clip_rect = this.clipRect;
				var oBodyPr = this.getBodyPr();
				if (!this.bWordShape) {
					if (oBodyPr.vertOverflow === AscFormat.nVOTOverflow) {
						return;
					}
				}
				if (!oBodyPr || !oBodyPr.upright) {
					graphics.transform3(transform_);
					graphics.AddClipRect(clip_rect.x, clip_rect.y, clip_rect.w, clip_rect.h);

					graphics.SetIntegerGrid(false);
					graphics.transform3(transformText_, true);
				} else {
					var oTransform = new CMatrix();
					var cX = transform_.TransformPointX(this.extX / 2, this.extY / 2);
					var cY = transform_.TransformPointY(this.extX / 2, this.extY / 2);

					if (checkNormalRotate(this.rot)) {
						oTransform.tx = cX - this.extX / 2;
						oTransform.ty = cY - this.extY / 2;
					} else {
						global_MatrixTransformer.TranslateAppend(oTransform, -this.extX / 2, -this.extY / 2);
						global_MatrixTransformer.RotateRadAppend(oTransform, Math.PI / 2);
						global_MatrixTransformer.TranslateAppend(oTransform, cX, cY);
					}
					graphics.transform3(oTransform, true);
					graphics.AddClipRect(clip_rect.x, clip_rect.y, clip_rect.w, clip_rect.h);

					graphics.SetIntegerGrid(false);
					graphics.transform3(transformText_, true);
				}
			}
		};
		CShape.prototype.drawTxBody = function (graphics, transform, transformText, pageIndex) {
			if (this.txBody) {
				var oController = this.getDrawingObjectsController && this.getDrawingObjectsController();
				graphics.SaveGrState();
				graphics.SetIntegerGrid(false);
				var _transformText;
				if ((!this.txBody.content || this.txBody.content.Is_Empty()) && !AscCommon.IsShapeToImageConverter && this.txBody.content2 != null && !this.txBody.checkCurrentPlaceholder() && (this.isEmptyPlaceholder ? this.isEmptyPlaceholder() : false) && this.transformText2) {
					_transformText = this.transformText2;
				} else if (this.txBody.content) {
					_transformText = transformText;
				}
				let isPdfAnnot = false;
				if (Asc.editor.isPdfEditor()) {
					if (this.IsAnnot && this.IsAnnot()) {
						isPdfAnnot = true;
					}
				}
				if (this instanceof CShape) {
					if (!(oController && (AscFormat.getTargetTextObject(oController) === this)) && !isPdfAnnot)
						this.clipTextRect(graphics, transform, transformText, pageIndex);
				}
				graphics.transform3(_transformText, true);
				if (graphics.CheckUseFonts2 !== undefined)
					graphics.CheckUseFonts2(_transformText);

				graphics.SetIntegerGrid(true);
				this.txBody.draw(graphics);
				if (graphics.UncheckUseFonts2 !== undefined)
					graphics.UncheckUseFonts2(_transformText);
				graphics.RestoreGrState();
			}
		};
		/**
		 * note: sometimes call to recalculate bounds
		 * @memberOf CShape
		 */
		CShape.prototype.draw = function (graphics, transform, transformText, pageIndex, opt) {

			if (this.checkNeedRecalculate && this.checkNeedRecalculate()) {
				return;
			}

			var oUR = graphics.updatedRect;
			if (oUR && this.bounds) {
				if (!oUR.isIntersectOther(this.bounds)) {
					return;
				}
			}
			if (graphics.animationDrawer) {
				graphics.animationDrawer.drawObject(this, graphics);
				return;
			}
			var options = opt || {};
			var _transform = transform ? transform : this.transform;
			var _transform_text = transformText ? transformText : this.transformText;
			var _transform_text2 = options.transformText2 || this.transformText2;
			var geometry = this.getGeometry();

			if (graphics.isBoundsChecker()) {

				this.drawShdw && this.drawShdw(graphics);
				graphics.transform3(_transform);
				if (!this.spPr || null == geometry || geometry.isEmpty() || !graphics.IsShapeNeedBounds(geometry.preset)) {
					graphics._s();
					graphics._m(0, 0);
					graphics._l(this.extX, 0);
					graphics._l(this.extX, this.extY);
					graphics._l(0, this.extY);
					graphics._e();
				} else {
					geometry.check_bounds(graphics, this);
				}

				if (this.txBody) {
					graphics.SetIntegerGrid(false);

					var transform_text;
					if ((!this.txBody.content || this.txBody.content.Is_Empty()) && this.txBody.content2 != null && !this.txBody.checkCurrentPlaceholder() && (this.isEmptyPlaceholder ? this.isEmptyPlaceholder() : false) && this.transformText2) {
						transform_text = _transform_text2;
					} else if (this.txBody.content) {
						transform_text = _transform_text;
					}

					graphics.transform3(transform_text);

					if (graphics.CheckUseFonts2 !== undefined)
						graphics.CheckUseFonts2(transform_text);
					this.txBody.draw(graphics);
					if (graphics.UncheckUseFonts2 !== undefined)
						graphics.UncheckUseFonts2(transform_text);
					graphics.SetIntegerGrid(true);
				}

				graphics.reset();
				return;
			}

			if (graphics.StartDrawShape) {
				graphics.StartDrawShape(undefined, this.isForm && this.isForm() ? true : false);
			}
			var oClipRect;
			if (!graphics.isBoundsChecker() && this.getClipRect) {
				oClipRect = this.getClipRect();
			}
			if (oClipRect) {
				graphics.SaveGrState();
				graphics.AddClipRect(oClipRect.x, oClipRect.y, oClipRect.w, oClipRect.h);
			}
			this.drawShdw && this.drawShdw(graphics);
			var _oldBrush = this.brush;
			if (this.signatureLine) {
				var sSignatureUrl = null;

				var _editor = window["Asc"]["editor"] ? window["Asc"]["editor"] : window.editor;
				if (_editor) {
					sSignatureUrl = _editor.asc_getSignatureImage(this.signatureLine.id);
				}
				if (typeof sSignatureUrl === "string" && sSignatureUrl.length > 0) {
					this.brush = AscFormat.CreateBlipFillUniFillFromUrl(sSignatureUrl);
				}
			}

			if ((geometry || (this.getObjectType && (this.getObjectType() === AscDFH.historyitem_type_DLbl || this.getObjectType() === AscDFH.historyitem_type_Title || this.getObjectType() === AscDFH.historyitem_type_Legend))) && (this.style || (this.brush && this.brush.fill) || (this.pen && this.pen.Fill && this.pen.Fill.fill))) {
				graphics.SetIntegerGrid(false);
				graphics.transform3(_transform, false);

				var shape_drawer = new AscCommon.CShapeDrawer();
				shape_drawer.fromShape2(this, graphics, geometry);
				shape_drawer.draw(geometry);
			}

			this.brush = _oldBrush;
			var oController = this.getDrawingObjectsController && this.getDrawingObjectsController();

			if (!this.cropObject) {
				if (!this.txWarpStruct && !this.txWarpStructParamarksNoTransform || (!this.txWarpStructParamarksNoTransform && oController && (AscFormat.getTargetTextObject(oController) === this) || (!this.txBody && !this.textBoxContent)) /*|| this.haveSelectedDrawingInContent()*/) {
					this.drawTxBody(graphics, transform, _transform_text, pageIndex);

					if (this.textBoxContent && graphics.isSupportTextDraw() && this.transformText) {
						var old_start_page = this.textBoxContent.GetRelativeStartPage();
						this.textBoxContent.Set_StartPage(pageIndex);

						graphics.SaveGrState();
						graphics.SetIntegerGrid(false);
						this.clipTextRect(graphics, transform, transformText, pageIndex);
						var result_page_index = AscFormat.isRealNumber(graphics.shapePageIndex) ? graphics.shapePageIndex : old_start_page;

						if (graphics.CheckUseFonts2 !== undefined)
							graphics.CheckUseFonts2(this.transformText, this.isForm && this.isForm() ? true : false);

						if (AscCommon.IsShapeToImageConverter) {
							this.textBoxContent.Set_StartPage(0);
							result_page_index = 0;
						}


						this.textBoxContent.Set_StartPage(result_page_index);
						this.textBoxContent.Draw(result_page_index, graphics);

						if (graphics.UncheckUseFonts2 !== undefined)
							graphics.UncheckUseFonts2();

						this.textBoxContent.Set_StartPage(old_start_page);
						graphics.RestoreGrState();
					}
				} else {
					var oTheme = this.getParentObjects().theme;
					var oColorMap = this.Get_ColorMap();
					var bEditTextArt = isRealObject(oController) && (AscFormat.getTargetTextObject(oController) === this);
					if (!this.bWordShape && (!this.txBody.content || this.txBody.content.Is_Empty()) && !AscCommon.IsShapeToImageConverter && this.txBody.content2 != null && !this.txBody.checkCurrentPlaceholder() && (this.isEmptyPlaceholder ? this.isEmptyPlaceholder() : false)) {
						if (graphics.IsNoDrawingEmptyPlaceholder !== true && graphics.IsNoDrawingEmptyPlaceholderText !== true && !graphics.isPdf()) {
							if (isShowParaMarksInTextArt(this, bEditTextArt)) {
								this.txWarpStructParamarks2.draw(graphics, this.transformTextWordArt2, oTheme, oColorMap);
							} else {
								if (this.txWarpStruct2)
									this.txWarpStruct2.draw(graphics, this.transformTextWordArt2, oTheme, oColorMap);
							}
						}
					} else {

						var oContent = this.getDocContent();
						var result_page_index = AscFormat.isRealNumber(graphics.shapePageIndex) ? graphics.shapePageIndex : (oContent ? oContent.GetRelativeStartPage() : 0);
						graphics.PageNum = result_page_index;
						var bNeedRestoreState = false;
						if (this.bWordShape && this.clipRect /*&& (!this.bodyPr.prstTxWarp || this.bodyPr.prstTxWarp.preset === "textNoShape" || bEditTextArt)*/) {
							bNeedRestoreState = true;
							var clip_rect = this.clipRect;
							if (!this.bodyPr.upright) {
								graphics.SaveGrState();
								graphics.SetIntegerGrid(false);
								graphics.transform3(this.transform);
								graphics.AddClipRect(clip_rect.x, clip_rect.y, clip_rect.w, clip_rect.h);
							} else {
								graphics.SaveGrState();
								graphics.SetIntegerGrid(false);
								graphics.transform3(this.transformText, true);
								graphics.AddClipRect(clip_rect.x, clip_rect.y, clip_rect.w, clip_rect.h);
							}
						}

						var oTransform = this.transformTextWordArt;
						if (isShowParaMarksInTextArt(this, bEditTextArt)) {
							if (bEditTextArt && this.txWarpStructParamarksNoTransform) {
								this.txWarpStructParamarksNoTransform.draw(graphics, this.transformText, oTheme, oColorMap);
							} else if (this.txWarpStructParamarks) {
								this.txWarpStructParamarks.draw(graphics, oTransform, oTheme, oColorMap);
								if (this.checkNeedRecalcDocContentForTxWarp(this.bodyPr)) {
									if (this.txWarpStructParamarksNoTransform) {
										this.txWarpStructParamarksNoTransform.drawComments(graphics, undefined, oTransform);
									}
								}
							}
						} else {
							if (bEditTextArt && this.txWarpStructNoTransform) {
								this.txWarpStructNoTransform.draw(graphics, this.transformText, oTheme, oColorMap);
							} else if (this.txWarpStruct) {
								this.txWarpStruct.draw(graphics, oTransform, oTheme, oColorMap);
								if (this.checkNeedRecalcDocContentForTxWarp(this.bodyPr)) {
									if (this.txWarpStructNoTransform) {
										this.txWarpStructNoTransform.drawComments(graphics, undefined, oTransform);
									}
								}
							}
						}
						delete graphics.PageNum;
						if (bNeedRestoreState) {
							graphics.RestoreGrState();
						}
					}
				}
			}
			this.drawLocks && this.drawLocks(_transform, graphics);
			if (oClipRect) {
				graphics.RestoreGrState();
			}
			//if(this.txXfrm && this.group) {
			//    graphics.SetIntegerGrid(false);
			//    _transform = new AscCommon.CMatrix();
			//    _transform.tx = this.txXfrm.offX + this.txXfrm.extX / 2 + this.group.transform.tx;
			//    _transform.ty = this.txXfrm.offY + this.txXfrm.extY / 2 + this.group.transform.ty;
			//    graphics.transform3(_transform, false);
			//    graphics.b_color1(255, 0, 0, 255);
			//    graphics.rect(-2, -2, 4, 4);
			//    graphics.df();
			//
			//    graphics.p_color(255, 0, 0, 255);
			//    graphics.rect(-this.txXfrm.extX / 2, -this.txXfrm.extY / 2, this.txXfrm.extX, this.txXfrm.extY);
			//    graphics.ds();
			//}

			let bMasterPh = false;
			if(Asc.editor.isMasterMode &&
				Asc.editor.isMasterMode() &&
				this.isPlaceholder && this.isPlaceholder()) {
				bMasterPh = true;
			}
			if (/*(!(this.pen && this.pen.Fill && this.pen.Fill.fill && !(this.pen.Fill.fill instanceof AscFormat.CNoFill)) && AscCommon.IS_GENERATE_SMARTART_AND_TEXT_ON_OPEN) || */(!graphics.isSmartArtPreviewDrawer && !graphics.isPdf() && !this.bWordShape && (this.isEmptyPlaceholder() && !this.isObjectInSmartArt() || bMasterPh) && !(this.parent && this.parent.kind === AscFormat.TYPE_KIND.NOTES) && !(this.pen && this.pen.Fill && this.pen.Fill.fill && !(this.pen.Fill.fill instanceof AscFormat.CNoFill)) && (graphics.IsNoDrawingEmptyPlaceholder !== true || bMasterPh) && !AscCommon.IsShapeToImageConverter)
				|| (Asc.editor.isPdfEditor() && !graphics.isPdf() && !graphics.isSmartArtPreviewDrawer && this.IsDrawing && this.IsDrawing() && this.ShouldDrawImaginaryBorder(graphics) && (graphics.IsNoDrawingEmptyPlaceholder !== true || bMasterPh) && !AscCommon.IsShapeToImageConverter)) {
					var drawingObjects = this.getDrawingObjectsController();
					if (typeof editor !== "undefined" && editor && graphics.m_oContext !== undefined && graphics.m_oContext !== null && !graphics.isTrack() && (Asc.editor.isPdfEditor() || !drawingObjects || AscFormat.getTargetTextObject(drawingObjects) !== this)) {
						var angle = _transform.GetRotation();
						if (AscFormat.fApproxEqual(angle, 0.0, 0.0) ||
							AscFormat.fApproxEqual(angle, 90.0, 0.0) ||
							AscFormat.fApproxEqual(angle, 180.0, 0.0) ||
							AscFormat.fApproxEqual(angle, 270.0, 0.0)) {
							graphics.transform3(_transform, false);
							var tr = graphics.m_oFullTransform;
							graphics.SetIntegerGrid(true);
	
							var _x = tr.TransformPointX(0, 0);
							var _y = tr.TransformPointY(0, 0);
							var _r = tr.TransformPointX(this.extX, this.extY);
							var _b = tr.TransformPointY(this.extX, this.extY);
	
							var __x = Math.min(_x, _r);
							var __y = Math.min(_y, _b);
							var __r = Math.max(_x, _r);
							var __b = Math.max(_y, _b);
							graphics.m_oContext.lineWidth = 1;
							graphics.p_color(127, 127, 127, 255);
	
							graphics._s();
							editor.WordControl.m_oDrawingDocument.AutoShapesTrack.AddRectDashClever(graphics.m_oContext, __x >> 0, __y >> 0, __r >> 0, __b >> 0, 2, 2, true);
							graphics._s();
						} else {
							graphics.transform3(_transform, false);
							var tr = graphics.m_oFullTransform;
							graphics.SetIntegerGrid(true);
	
							var _r = this.extX;
							var _b = this.extY;
	
							var x1 = tr.TransformPointX(0, 0) >> 0;
							var y1 = tr.TransformPointY(0, 0) >> 0;
	
							var x2 = tr.TransformPointX(_r, 0) >> 0;
							var y2 = tr.TransformPointY(_r, 0) >> 0;
	
							var x3 = tr.TransformPointX(0, _b) >> 0;
							var y3 = tr.TransformPointY(0, _b) >> 0;
	
							var x4 = tr.TransformPointX(_r, _b) >> 0;
							var y4 = tr.TransformPointY(_r, _b) >> 0;
	
							graphics.m_oContext.lineWidth = 1;
							graphics.p_color(127, 127, 127, 255);
	
							graphics._s();
							editor.WordControl.m_oDrawingDocument.AutoShapesTrack.AddRectDash(graphics.m_oContext, x1, y1, x2, y2, x3, y3, x4, y4, 3, 1, true);
							graphics._s();
						}
					} else {
						graphics.SetIntegerGrid(false);
						graphics.p_width(70);
						graphics.transform3(_transform, false);
						graphics.p_color(0, 0, 0, 255);
						graphics._s();
						graphics._m(0, 0);
						graphics._l(this.extX, 0);
						graphics._l(this.extX, this.extY);
						graphics._l(0, this.extY);
						graphics._z();
						graphics.ds();
	
						graphics.SetIntegerGrid(true);
					}
				}

			graphics.SetIntegerGrid(true);
			graphics.reset();
			if (graphics.EndDrawShape) {
				graphics.EndDrawShape();
			}
		};

		CShape.prototype.recalculateGeometry = function () {
			this.calcGeometry = null;
			if (isRealObject(this.spPr && this.spPr.geometry)) {
				this.calcGeometry = this.spPr.geometry;
			} else {
				if (this.getHierarchy) {
					var hierarchy = this.getHierarchy();
					for (var i = 0; i < hierarchy.length; ++i) {
						if (hierarchy[i] && hierarchy[i].spPr && hierarchy[i].spPr.geometry) {
							var _g = hierarchy[i].spPr.geometry;
							this.calcGeometry = AscFormat.ExecuteNoHistory(function () {
								var _r = _g.createDuplicate();
								_r.setParent(this);
								return _r;
							}, this, []);
							break;
						}
					}
				}
			}
			if (isRealObject(this.calcGeometry)) {
				var transform = this.getTransform();
				this.calcGeometry.Recalculate(transform.extX, transform.extY);
			}
		};

		CShape.prototype.getRotateAngle = function (x, y) {
			var transform = this.getTransformMatrix();
			var rotate_distance = this.convertPixToMM(AscCommon.TRACK_DISTANCE_ROTATE);
			var hc = this.extX * 0.5;
			var vc = this.extY * 0.5;
			var xc_t = transform.TransformPointX(hc, vc);
			var yc_t = transform.TransformPointY(hc, vc);
			var rot_x_t = transform.TransformPointX(hc, -rotate_distance);
			var rot_y_t = transform.TransformPointY(hc, -rotate_distance);

			var invert_transform = this.getInvertTransform();
			if (!invert_transform) {
				return 0.0;
			}
			var rel_x = invert_transform.TransformPointX(x, y);

			var v1_x, v1_y, v2_x, v2_y;
			v1_x = x - xc_t;
			v1_y = y - yc_t;

			v2_x = rot_x_t - xc_t;
			v2_y = rot_y_t - yc_t;

			var flip_h = this.getFullFlipH();
			var flip_v = this.getFullFlipV();
			var same_flip = flip_h && flip_v || !flip_h && !flip_v;
			var angle = rel_x > this.extX * 0.5 ? Math.atan2(Math.abs(v1_x * v2_y - v1_y * v2_x), v1_x * v2_x + v1_y * v2_y) : -Math.atan2(Math.abs(v1_x * v2_y - v1_y * v2_x), v1_x * v2_x + v1_y * v2_y);
			return same_flip ? angle : -angle;
		};

		CShape.prototype.getInvertTransform = function () {
			return this.invertTransform ? this.invertTransform : new CMatrix();
		};


		CShape.prototype.getFullOffset = function () {
			if (!isRealObject(this.group))
				return {offX: this.x, offY: this.y};
			var group_offset = this.group.getFullOffset();
			return {offX: this.x + group_offset.offX, offY: this.y + group_offset.offY};
		};


		CShape.prototype.getTextArtProperties = function () {
			var oContent = this.getDocContent(), oTextPr, oRet = null;
			if (oContent) {
				oRet = {Fill: undefined, Line: undefined, Form: undefined};
				var oController = this.getDrawingObjectsController();
				// if(oController)
				{
					//var oTargetDocContent = oController.getTargetDocContent();
					//if(oTargetDocContent === oContent)
					//{
					//    oTextPr = oContent.GetCalculatedTextPr();
					//}
					//else
					//{
					//    oContent.SetApplyToAll(true);
					//    oTextPr = oContent.GetCalculatedTextPr();
					//    oContent.SetApplyToAll(false);
					//}
					//if(oTextPr.TextFill)
					//{
					//    oRet.Fill = oTextPr.TextFill;
					//}
					//else if(oTextPr.Unifill)
					//{
					//    oRet.Fill = oTextPr.Unifill;
					//}
					//else if(oTextPr.Color)
					//{
					//    oRet.Fill = CreateUnfilFromRGB(oTextPr.Color.r, oTextPr.Color.g, oTextPr.Color.b);
					//}
					//oRet.Line = oTextPr.TextOutline;
					var oBodyPr = this.getBodyPr();
					if (oBodyPr && oBodyPr.prstTxWarp) {
						oRet.Form = oBodyPr.prstTxWarp.preset;
					} else {
						oRet.Form = "textNoShape";
					}
				}
			}
			return oRet;
		};

		CShape.prototype.applyTextArtForm = function (sPreset) {
			var oBodyPr = this.getBodyPr().createDuplicate();
			oBodyPr.prstTxWarp = AscFormat.CreatePrstTxWarpGeometry(sPreset);
			if (this.bWordShape) {
				this.setBodyPr(oBodyPr);
			} else {
				if (this.txBody) {
					this.txBody.setBodyPr(oBodyPr);
				}
			}
		};

		CShape.prototype.getParagraphParaPr = function () {
			if (this.txBody && this.txBody.content) {
				var _result;
				this.txBody.content.SetApplyToAll(true);
				_result = this.txBody.content.GetCalculatedParaPr();
				this.txBody.content.SetApplyToAll(false);
				return _result;
			}
			return null;
		};

		CShape.prototype.getParagraphTextPr = function () {
			if (this.txBody && this.txBody.content) {
				var _result;
				this.txBody.content.SetApplyToAll(true);
				_result = this.txBody.content.GetCalculatedTextPr();
				this.txBody.content.SetApplyToAll(false);
				return _result;
			}
			return null;
		};

		CShape.prototype.getImageFromBulletsMap = function (oImages) {
			const oContent = this.getDocContent();
			if (!oContent) {
				return;
			}
			const aParagraphs = oContent.Content;
			for (let nPar = 0; nPar < aParagraphs.length; ++nPar) {
				var oPr = aParagraphs[nPar].Pr;
				if (oPr.Bullet) {
					const sImageId = oPr.Bullet.getImageBulletURL();
					if (sImageId) {
						oImages[sImageId] = true;
					}
				}
			}
		};

		CShape.prototype.getDocContentsWithImageBullets = function (arrContents) {
			const oContent = this.getDocContent();
			if (!oContent) {
				return;
			}
			const aParagraphs = oContent.Content;
			for (let nPar = 0; nPar < aParagraphs.length; ++nPar) {
				var oPr = aParagraphs[nPar].Pr;
				if (oPr.Bullet) {
					const sImageId = oPr.Bullet.getImageBulletURL();
					if (sImageId) {
						arrContents.push(oContent);
						break;
					}
				}
			}
		}

		CShape.prototype.getAllRasterImages = function (images) {
			if (this.spPr && this.spPr.Fill && this.spPr.Fill.fill && typeof (this.spPr.Fill.fill.RasterImageId) === "string" && this.spPr.Fill.fill.RasterImageId.length > 0)
				images.push(this.spPr.Fill.fill.RasterImageId);


			var compiled_style = this.getCompiledStyle();
			var parents = this.getParentObjects();
			if (isRealObject(parents.theme) && isRealObject(compiled_style) && isRealObject(compiled_style.fillRef)) {
				var brush = parents.theme.getFillStyle(compiled_style.fillRef.idx, compiled_style.fillRef.Color);
				if (brush && brush.fill && typeof (brush.fill.RasterImageId) === "string" && brush.fill.RasterImageId.length > 0) {
					images.push(brush.fill.RasterImageId);
				}
			}
			var oContent = this.getDocContent();
			fCheckContentImages(images, oContent, this.bWordShape);
		};

		function fCheckContentImages(images, oContent, bWord) {
			if (oContent) {
				if (bWord) {
					var drawings = oContent.GetAllDrawingObjects();
					for (var i = 0; i < drawings.length; ++i) {
						drawings[i].GraphicObj && drawings[i].GraphicObj.getAllRasterImages && drawings[i].GraphicObj.getAllRasterImages(images);
					}
				} else {
					oContent.getBulletImages(images);
				}
				var fCallback = function (oRun) {
					var oTextPr = oRun && oRun.Pr;
					if (oTextPr && oTextPr.Unifill && oTextPr.Unifill.fill && oTextPr.Unifill.fill.type == c_oAscFill.FILL_TYPE_BLIP) {
						images.push(oTextPr.Unifill.fill.RasterImageId);
					}
					return false;
				};

				oContent.CheckRunContent(fCallback);
			}
		}
		CShape.prototype.getAllDocContents = function (aDocContents) {
			if (this.textBoxContent) {
				aDocContents.push(this.textBoxContent);
			}
		};

		CShape.prototype.checkRunContent = function (fCallback) {
			let oContent = this.getDocContent();
			if (oContent) {
				oContent.CheckRunContent(fCallback);
			}
		};

		CShape.prototype.changePositionInSmartArt = function (newX, newY) {
			if (this.isObjectInSmartArt()) {
				var point = this.getSmartArtShapePoint();
				if (point) {
					var prSet = point.getPrSet();
					if (prSet) {
						var originalPosX;
						var originalPosY;
						var defaultExtX;
						var defaultExtY;
						var isNormalRotate = AscFormat.checkNormalRotate(this.getDefaultRotSA());
						if (isNormalRotate) {
							originalPosX = this.x;
							originalPosY = this.y;
							defaultExtX = this.extX;
							defaultExtY = this.extY;
						} else {
							originalPosX = this.x + (this.extX - this.extY) / 2;
							originalPosY = this.y + (this.extY - this.extX) / 2;
							defaultExtX = this.extY;
							defaultExtY = this.extX;
						}


						if (prSet) {
							if (prSet.custScaleX) {
								defaultExtX /= prSet.custScaleX;
							}
							if (prSet.custScaleY) {
								defaultExtY /= prSet.custScaleY;
							}
							if (prSet.custLinFactNeighborX) {
								originalPosX -= (prSet.custLinFactNeighborX) * defaultExtX;
							}
							if (prSet.custLinFactNeighborY) {
								originalPosY -= (prSet.custLinFactNeighborY) * defaultExtY;
							}
							if (prSet.custLinFactX) {
								originalPosX -= (prSet.custLinFactX) * defaultExtX;
							}
							if (prSet.custLinFactY) {
								originalPosY -= (prSet.custLinFactY) * defaultExtY;
							}
							if (this.x !== newX) {
								if (prSet.custLinFactNeighborX) {
									prSet.setCustLinFactNeighborX(null);
								}
								prSet.setCustLinFactX(((newX - originalPosX) / defaultExtX));
							}
							if (this.y !== newY) {
								if (prSet.custLinFactNeighborY) {
									prSet.setCustLinFactNeighborY(null);
								}
								prSet.setCustLinFactY(((newY - originalPosY) / defaultExtY));
							}
						}
					}
				}
			}
		};

		CShape.prototype.changePresetGeom = function (sPreset) {


			if (sPreset === "textRect") {
				if (this.isObjectInSmartArt()) {
					return;
				}
				this.spPr.setGeometry(AscFormat.CreateGeometry("rect"));

				if (this.bWordShape) {
					if (this.style) {
						this.setStyle(null);
					}
				} else {
					this.setStyle(AscFormat.CreateDefaultTextRectStyle());
				}

				var fill = new AscFormat.CUniFill();
				fill.setFill(new AscFormat.CSolidFill());
				fill.fill.setColor(new AscFormat.CUniColor());
				fill.fill.color.setColor(new AscFormat.CSchemeColor());
				fill.fill.color.color.setId(12);
				this.spPr.setFill(fill);

				var ln = new AscFormat.CLn();
				ln.setW(6350);
				ln.setFill(new AscFormat.CUniFill());
				ln.Fill.setFill(new AscFormat.CSolidFill());
				ln.Fill.fill.setColor(new AscFormat.CUniColor());
				ln.Fill.fill.color.setColor(new AscFormat.CPrstColor());
				ln.Fill.fill.color.color.setId("black");
				this.spPr.setLn(ln);
				if (this.bWordShape) {
					if (!this.textBoxContent) {
						this.setTextBoxContent(new CDocumentContent(this, this.getDrawingDocument(), 0, 0, 0, 0, false, false, false));
						var body_pr = new AscFormat.CBodyPr();
						body_pr.setDefault();
						this.setBodyPr(body_pr);
					}
				} else {
					if (!this.txBody) {
						this.setTxBody(new AscFormat.CTextBody());
						var content = new AscFormat.CDrawingDocContent(this.txBody, this.getDrawingDocument(), 0, 0, 0, 0, false, false, true);
						this.txBody.setParent(this);
						this.txBody.setContent(content);
						var body_pr = new AscFormat.CBodyPr();
						body_pr.setDefault();
						this.txBody.setBodyPr(body_pr);
					}
				}
				return;
			}
			var _final_preset;
			var _old_line;
			var _new_line;


			if (this.spPr.ln == null) {
				_old_line = null;
			} else {
				_old_line = this.spPr.ln.createDuplicate();
			}
			switch (sPreset) {
				case "lineWithArrow": {
					_final_preset = "line";
					if (_old_line == null) {
						_new_line = new AscFormat.CLn();
					} else {
						_new_line = this.spPr.ln.createDuplicate();
					}
					_new_line.tailEnd = new AscFormat.EndArrow();
					_new_line.tailEnd.type = AscFormat.LineEndType.Arrow;
					_new_line.tailEnd.len = AscFormat.LineEndSize.Mid;
					_new_line.tailEnd.w = AscFormat.LineEndSize.Mid;
					break;
				}
				case "lineWithTwoArrows": {
					_final_preset = "line";
					if (_old_line == null) {
						_new_line = new AscFormat.CLn();

					} else {
						_new_line = this.spPr.ln.createDuplicate();
					}
					_new_line.tailEnd = new AscFormat.EndArrow();
					_new_line.tailEnd.type = AscFormat.LineEndType.Arrow;
					_new_line.tailEnd.len = AscFormat.LineEndSize.Mid;
					_new_line.tailEnd.w = AscFormat.LineEndSize.Mid;

					_new_line.headEnd = new AscFormat.EndArrow();
					_new_line.headEnd.type = AscFormat.LineEndType.Arrow;
					_new_line.headEnd.len = AscFormat.LineEndSize.Mid;
					_new_line.headEnd.w = AscFormat.LineEndSize.Mid;
					break;
				}
				case "bentConnector5WithArrow": {
					_final_preset = "bentConnector5";
					if (_old_line == null) {
						_new_line = new AscFormat.CLn();

					} else {
						_new_line = this.spPr.ln.createDuplicate();
					}
					_new_line.tailEnd = new AscFormat.EndArrow();
					_new_line.tailEnd.type = AscFormat.LineEndType.Arrow;
					_new_line.tailEnd.len = AscFormat.LineEndSize.Mid;
					_new_line.tailEnd.w = AscFormat.LineEndSize.Mid;
					break;
				}
				case "bentConnector5WithTwoArrows": {
					_final_preset = "bentConnector5";
					if (_old_line == null) {
						_new_line = new AscFormat.CLn();
					} else {
						_new_line = this.spPr.ln.createDuplicate();
					}
					_new_line.tailEnd = new AscFormat.EndArrow();
					_new_line.tailEnd.type = AscFormat.LineEndType.Arrow;
					_new_line.tailEnd.len = AscFormat.LineEndSize.Mid;
					_new_line.tailEnd.w = AscFormat.LineEndSize.Mid;

					_new_line.headEnd = new AscFormat.EndArrow();
					_new_line.headEnd.type = AscFormat.LineEndType.Arrow;
					_new_line.headEnd.len = AscFormat.LineEndSize.Mid;
					_new_line.headEnd.w = AscFormat.LineEndSize.Mid;
					break;
				}
				case "curvedConnector3WithArrow": {
					_final_preset = "curvedConnector3";
					if (_old_line == null) {
						_new_line = new AscFormat.CLn();
					} else {
						_new_line = this.spPr.ln.createDuplicate();
					}
					_new_line.tailEnd = new AscFormat.EndArrow();
					_new_line.tailEnd.type = AscFormat.LineEndType.Arrow;
					_new_line.tailEnd.len = AscFormat.LineEndSize.Mid;
					_new_line.tailEnd.w = AscFormat.LineEndSize.Mid;
					break;
				}
				case "curvedConnector3WithTwoArrows": {
					_final_preset = "curvedConnector3";
					if (_old_line == null) {
						_new_line = new AscFormat.CLn();

					} else {
						_new_line = this.spPr.ln.createDuplicate();
					}
					_new_line.tailEnd = new AscFormat.EndArrow();
					_new_line.tailEnd.type = AscFormat.LineEndType.Arrow;
					_new_line.tailEnd.len = AscFormat.LineEndSize.Mid;
					_new_line.tailEnd.w = AscFormat.LineEndSize.Mid;

					_new_line.headEnd = new AscFormat.EndArrow();
					_new_line.headEnd.type = AscFormat.LineEndType.Arrow;
					_new_line.headEnd.len = AscFormat.LineEndSize.Mid;
					_new_line.headEnd.w = AscFormat.LineEndSize.Mid;
					break;
				}
				default: {
					_final_preset = sPreset;
					if (_old_line == null) {
						_new_line = new AscFormat.CLn();
					} else {
						_new_line = this.spPr.ln.createDuplicate();
					}
					_new_line.tailEnd = null;

					_new_line.headEnd = null;
					break;
				}
			}
			var point = this.getSmartArtShapePoint();
			if (_final_preset != null) {
				this.spPr.setGeometry(AscFormat.CreateGeometry(_final_preset));
				point && point.setGeometry(AscFormat.CreateGeometry(_final_preset));
			} else {
				this.spPr.setGeometry(null);
				point && point.setGeometry(null);
			}
			if (!this.bWordShape) {
				this.checkExtentsByDocContent();
			}
			var setLine = _new_line;
			if ((!this.brush || !this.brush.fill) && (!this.pen || !this.pen.Fill || !this.pen.Fill.fill)) {
				var new_line2 = new AscFormat.CLn();
				new_line2.Fill = new AscFormat.CUniFill();
				new_line2.Fill.fill = new AscFormat.CSolidFill();
				new_line2.Fill.fill.color = new AscFormat.CUniColor();
				new_line2.Fill.fill.color.color = new AscFormat.CSchemeColor();
				new_line2.Fill.fill.color.color.id = 0;
				if (isRealObject(_new_line)) {
					new_line2.merge(_new_line);
				}
				setLine = new_line2;
			}
			this.spPr.setLn(setLine);
			point && point.setLine(setLine);
		};

		CShape.prototype.changeFill = function (unifill) {

			if (this.recalcInfo.recalculateBrush) {
				this.recalculateBrush();
			}
			var unifill2 = AscFormat.CorrectUniFill(unifill, this.brush, this.getEditorType());
			unifill2.convertToPPTXMods();
			this.setFill(unifill2);
			if(this.useBgFill) {
				this.setUseBgFill(null);
			}
			var point = this.getSmartArtShapePoint();
			if (point) {
				point.setUniFill(unifill2);
			}
		};
		CShape.prototype.changeShadow = function (oShadow) {

			this.spPr && this.spPr.changeShadow(oShadow);

			var point = this.getSmartArtShapePoint();
			point && point.changeShadow(oShadow);
		};
		CShape.prototype.setFill = function (fill) {

			this.spPr.setFill(fill);
		};

		CShape.prototype.changeLine = function (line) {
			if (this.recalcInfo.recalculatePen) {
				this.recalculatePen();
			}
			var stroke = AscFormat.CorrectUniStroke(line, this.pen);
			if (stroke.Fill) {
				stroke.Fill.convertToPPTXMods();
			}
			this.spPr.setLn(stroke);

			var point = this.getSmartArtShapePoint();
			point && point.setLine(stroke);
		};

		CShape.prototype.hitToAdjustment = function (x, y) {
			if (!AscFormat.canSelectDrawing(this)) {
				return false;
			}
			var oApi = Asc.editor || editor;
			var isDrawHandles = oApi ? oApi.isShowShapeAdjustments() : true;

			if (isDrawHandles && this.isForm && this.isForm() && this.getInnerForm() && this.getInnerForm().IsFormLocked())
				isDrawHandles = false;

			if (isDrawHandles === false) {
				return {hit: false, adjPolarFlag: null, adjNum: null, warp: false};
			}
			var invert_transform;
			var t_x, t_y, ret;
			var _calcGeom = this.getGeometry();
			var _dist;
			if (global_mouseEvent && global_mouseEvent.AscHitToHandlesEpsilon) {
				_dist = global_mouseEvent.AscHitToHandlesEpsilon;
			} else {
				_dist = this.convertPixToMM(global_mouseEvent.KoefPixToMM * AscCommon.TRACK_CIRCLE_RADIUS);
			}
			if (_calcGeom) {
				invert_transform = this.getInvertTransform();
				if (!invert_transform) {
					return {hit: false, adjPolarFlag: null, adjNum: null, warp: false};
				}
				t_x = invert_transform.TransformPointX(x, y);
				t_y = invert_transform.TransformPointY(x, y);
				ret = _calcGeom.hitToAdj(t_x, t_y, _dist);
				if (ret.hit) {
					ret.warp = false;
					return ret;
				}
			}
			if (this.recalcInfo.warpGeometry && this.invertTransformTextWordArt) {
				invert_transform = this.invertTransformTextWordArt;
				t_x = invert_transform.TransformPointX(x, y);
				t_y = invert_transform.TransformPointY(x, y);
				ret = this.recalcInfo.warpGeometry.hitToAdj(t_x, t_y, _dist);
				ret.warp = true;
				return ret;
			}

			return {hit: false, adjPolarFlag: null, adjNum: null, warp: false};
		};

		CShape.prototype.hit = function (x, y) {
			return this.hitInInnerArea(x, y) || this.hitInPath(x, y) || this.hitInTextRect(x, y);
		};

		CShape.prototype.hitInPath = function (x, y) {

			var oInnerForm = null;
			if (this.isForm && this.isForm() && (oInnerForm = this.getInnerForm()) && oInnerForm.CanPlaceCursorInside()) {
				var oApi = Asc.editor || editor;
				var oLogicDocument = oApi && oApi.WordControl && oApi.WordControl.m_oLogicDocument ? oApi.WordControl.m_oLogicDocument : null;
				if (oLogicDocument && oLogicDocument.IsDocumentEditor() && oLogicDocument.IsFillingFormMode())
					return false;
			}

			if (!this.checkHitToBounds(x, y))
				return false;
			var invert_transform = this.getInvertTransform();
			if (!invert_transform) {
				return false;
			}
			var x_t = invert_transform.TransformPointX(x, y);
			var y_t = invert_transform.TransformPointY(x, y);
			var oGeometry = this.spPr && this.spPr.geometry || this.calcGeometry;
			if (oGeometry) {
				const dOldDIst = AscFormat.DIST_HIT_IN_LINE;
				if(this.pen) {
					const nW = this.pen.w || 12700;
					const dWidth = nW / 36000;
					const oAPI = Asc.editor;
					if(oAPI.isEraseInkMode() && !oGeometry.preset) {
						AscFormat.DIST_HIT_IN_LINE = dWidth;
					}
					else {
						AscFormat.DIST_HIT_IN_LINE = Math.max(dOldDIst, dWidth);
					}
				}
				let bResult = oGeometry.hitInPath(this.getCanvasContext(), x_t, y_t);
				AscFormat.DIST_HIT_IN_LINE = dOldDIst;
				return bResult;
			}
			else
				return this.hitInBoundingRect(x, y);
			return false;
		};

		CShape.prototype.hitInInnerArea = function (x, y) {
			if ((this.getObjectType && this.getObjectType() === AscDFH.historyitem_type_ChartSpace || this.getObjectType() === AscDFH.historyitem_type_Title) ||
				(this.brush != null && this.brush.isVisible() || this.blipFill || (this.isTextBox && this.isTextBox())) && this.checkHitToBounds(x, y)) {
				var invert_transform = this.getInvertTransform();
				if (!invert_transform) {
					return false;
				}
				var x_t = invert_transform.TransformPointX(x, y);
				var y_t = invert_transform.TransformPointY(x, y);
				var oGeometry = this.getGeometry();
				if (isRealObject(oGeometry) && oGeometry.pathLst.length > 0 && !(this.getObjectType && this.getObjectType() === AscDFH.historyitem_type_ChartSpace))
					return oGeometry.hitInInnerArea(this.getCanvasContext(), x_t, y_t);
				if (this.getObjectType() === AscDFH.historyitem_type_Shape) {
					return false;
				}
				return x_t > 0 && x_t < this.extX && y_t > 0 && y_t < this.extY;
			}
			return false;
		};

		CShape.prototype.hitInBoundingRect = function (x, y) {
			if (!AscFormat.canSelectDrawing(this)) {
				return false;
			}
			var oInnerForm = null;
			if (this.isForm && this.isForm() && (oInnerForm = this.getInnerForm()) && oInnerForm.CanPlaceCursorInside()) {
				var oApi = Asc.editor || editor;
				var oLogicDocument = oApi && oApi.WordControl && oApi.WordControl.m_oLogicDocument ? oApi.WordControl.m_oLogicDocument : null;
				if (oLogicDocument && oLogicDocument.IsDocumentEditor() && oLogicDocument.IsFillingFormMode())
					return false;
			}

			if (this.parent && this.parent.kind === AscFormat.TYPE_KIND.NOTES) {
				return false;
			}
			var invert_transform = this.getInvertTransform();
			if (!invert_transform) {
				return false;
			}
			var x_t = invert_transform.TransformPointX(x, y);
			var y_t = invert_transform.TransformPointY(x, y);

			var _hit_context = this.getCanvasContext();

			return !(CheckObjectLine(this)) && (HitInLine(_hit_context, x_t, y_t, 0, 0, this.extX, 0) ||
				HitInLine(_hit_context, x_t, y_t, this.extX, 0, this.extX, this.extY) ||
				HitInLine(_hit_context, x_t, y_t, this.extX, this.extY, 0, this.extY) ||
				HitInLine(_hit_context, x_t, y_t, 0, this.extY, 0, 0) ||
				(this.canRotate && this.canRotate() && HitInLine(_hit_context, x_t, y_t, this.extX * 0.5, 0, this.extX * 0.5, -this.convertPixToMM(AscCommon.TRACK_DISTANCE_ROTATE))));
		};
		CShape.prototype.hitInTextHyperlink = function(x, y) {
			let oContent = this.getDocContent();
			let oInvTextTransform = this.invertTransformText;
			if (oContent && oInvTextTransform) {
				let tx = oInvTextTransform.TransformPointX(x, y);
				let ty = oInvTextTransform.TransformPointY(x, y);
				let oHitParagraph = oContent.IsInText(tx, ty, 0);
				if (oHitParagraph) {
					if (oHitParagraph.IsInText(tx, ty, 0)) {
						let oHyperlink = oHitParagraph.CheckHyperlink(tx, ty, 0);
						if (oHyperlink) {
							return oHyperlink;
						}
					}
				}
			}
			return null;
		};
		CShape.prototype.canRotate = function () {
			if (this.cropObject) {
				return false;
			}
			if (this.signatureLine) {
				return false;
			}
			return AscFormat.CGraphicObjectBase.prototype.canRotate.call(this);
		};


		CShape.prototype.canGroup = function () {
			if (this.isPlaceholder()) {
				return false;
			}
			if(this.isForm()) {
				return false;
			}
			if (this.signatureLine) {
				return false;
			}
			return AscFormat.CGraphicObjectBase.prototype.canGroup.call(this);
		};


		CShape.prototype.createRotateTrack = function () {
			return new AscFormat.RotateTrackShapeImage(this);
		};

		CShape.prototype.createResizeTrack = function (cardDirection, oController) {
			return new AscFormat.ResizeTrackShapeImage(this, cardDirection, oController);
		};

		CShape.prototype.setResizeHeightConstr = function (height) {
			AscFormat.CheckSpPrXfrm(this);
			if (AscFormat.isRealNumber(height)) {
				this.spPr.xfrm.setExtY(height);
			}
		}

		CShape.prototype.setResizeWidthConstr = function (width) {
			AscFormat.CheckSpPrXfrm(this);
			if (AscFormat.isRealNumber(width)) {
				this.spPr.xfrm.setExtX(width);
			}
		}

		CShape.prototype.createMoveTrack = function () {
			return new AscFormat.MoveShapeImageTrack(this);
		};


		CShape.prototype.getContentText = function () {
			return this.getText();
		};


		CShape.prototype.remove = function (Count, bOnlyText, bRemoveOnlySelection, bOnTextAdd, isWord) {
			if (this.txBody) {
				this.txBody.content.Remove(Count, bOnlyText, bRemoveOnlySelection, bOnTextAdd, isWord);
				this.recalcInfo.recalculateContent = true;
				this.recalcInfo.recalculateTransformText = true;
			}
		};

		CShape.prototype.getWatermarkProps = function () {
			var oProps = new Asc.CAscWatermarkProperties(), oTextPr, oRGBAColor, oInterfaceTextPr, oContent;
			oContent = this.getDocContent();
			oProps.put_Type(Asc.c_oAscWatermarkType.Text);
			oProps.setXfrmRot(AscFormat.normalizeRotate(this.getXfrmRot() || 0));
			oContent.SetApplyToAll(true);
			oProps.put_Text(oContent.GetSelectedText(true, {
				ParaSeparator : "",
				NewLineSeparator : "",
				TableCellSeparator : "",
				TableRowSeparator : ""
			}));
			oTextPr = oContent.GetCalculatedTextPr();
			oProps.put_Opacity(255);
			if (!AscFormat.isRealNumber(oTextPr.FontSize) ||
				oTextPr.FontSize < 36 ||
				oTextPr.FontSize - (oTextPr.FontSize >> 0) > 0) {
				oTextPr.FontSize = -1;
			}
			oInterfaceTextPr = new Asc.CTextProp(oTextPr);
			if (oTextPr.TextFill) {
				oTextPr.TextFill.check(this.Get_Theme(), this.Get_ColorMap());
				if (oTextPr.TextFill.fill && oTextPr.TextFill.fill.type === c_oAscFill.FILL_TYPE_SOLID && oTextPr.TextFill.fill.color) {
					oInterfaceTextPr.put_Color(AscCommon.CreateAscColor(oTextPr.TextFill.fill.color));
				} else {
					oRGBAColor = oTextPr.TextFill.getRGBAColor();
					oInterfaceTextPr.put_Color(AscCommon.CreateAscColorCustom(oRGBAColor.R, oRGBAColor.G, oRGBAColor.B, false));
				}
				oProps.put_Opacity(AscFormat.isRealNumber(oTextPr.TextFill.transparent) ? oTextPr.TextFill.transparent : 255);
			}
			oProps.put_TextPr(oInterfaceTextPr);
			oContent.SetApplyToAll(false);
			return oProps;
		};

		CShape.prototype.RestartSpellCheck = function () {
			this.recalcInfo.recalculateShapeStyleForParagraph = true;
			var content = this.getDocContent();
			content && content.RestartSpellCheck();
		};

		CShape.prototype.Refresh_RecalcData = function (data) {
			switch (data.Type) {
				case AscDFH.historyitem_AutoShapes_SetDrawingBaseCoors: {
					break;
				}
				case AscDFH.historyitem_AutoShapes_RemoveFromDrawingObjects: {
					break;
				}
				case AscDFH.historyitem_AutoShapes_AddToDrawingObjects: {
					break;
				}
				case AscDFH.historyitem_AutoShapes_SetWorksheet: {
					break;
				}
				case AscDFH.historyitem_ShapeSetBDeleted: {
					break;
				}
				case AscDFH.historyitem_ShapeSetNvSpPr: {
					break;
				}
				case AscDFH.historyitem_ShapeSetSpPr: {
					break;
				}
				case AscDFH.historyitem_ShapeSetStyle: {
					break;
				}
				case AscDFH.historyitem_ShapeSetTxBody: {
					this.Refresh_RecalcData2();
					break;
				}
				case AscDFH.historyitem_ShapeSetTextBoxContent: {
					this.Refresh_RecalcData2();
					break;
				}
				case AscDFH.historyitem_ShapeSetParent: {
					break;
				}
				case AscDFH.historyitem_ShapeSetGroup: {
					break;
				}
				case AscDFH.historyitem_ShapeSetBodyPr: {
					this.Refresh_RecalcData2();
					break;
				}
				case AscDFH.historyitem_ShapeSetWordShape: {
					break;
				}
				default: {
					this.Refresh_RecalcData2();
				}
			}
		};

		CShape.prototype.Refresh_RecalcData2 = function (pageIndex/*для текста*/) {
			this.recalcContent();
			this.recalcContent2 && this.recalcContent2();
			this.recalcTransformText();
			this.addToRecalculate();
			var oController = this.getDrawingObjectsController();
			if (oController && AscFormat.getTargetTextObject(oController) === this) {
				this.recalcInfo.recalcTitle = this.getDocContent();
				this.recalcInfo.bRecalculatedTitle = true;
			}
			if (this.parent && this.parent.getObjectType && this.parent.getObjectType() === AscDFH.historyitem_type_Notes) {
				if (this.parent.slide && this.parent.slide.addToRecalculate) {
					this.parent.slide.addToRecalculate();
				}
			}
		};
		
		CShape.prototype.GetPageContentFrame = function(page, sectPr){
			return this.GetColumnContentFrame(page, 0, sectPr);
		};
		
		CShape.prototype.GetColumnContentFrame = function(page, column, sectPr){
			if (this.textBoxContent) {
				if (this.getTextRect) {
					var rect = this.getTextRect();
					return {X: 0, Y: 0, XLimit: rect.r - rect.l, YLimit: 20000};
				} else {
					return {X: 0, Y: 0, XLimit: this.extX, YLimit: 20000};
				}
			}
			return null;
		};

		CShape.prototype.OnContentRecalculate = function () {
		};

		CShape.prototype.recalculateBounds = function () {
			const oBoundsChecker = new AscFormat.CSlideBoundsChecker();
			this.draw(oBoundsChecker, this.localTransform, this.localTransformText, undefined, {transformText2: this.localTransformText2});
			const oBounds = oBoundsChecker.Bounds;
			this.bounds.reset(oBounds.min_x, oBounds.min_y, oBounds.max_x, oBounds.max_y);
		};

		CShape.prototype.checkContentWordArt = function (oContent) {
			if (!oContent) {
				return false;
			}
			return oContent.CheckRunContent(CheckWordArtTextPr);
		};

		CShape.prototype.checkNeedRecalcDocContentForTxWarp = function (oBodyPr) {
			return oBodyPr && oBodyPr.prstTxWarp && (oBodyPr.prstTxWarp.pathLst.length / 2 - ((oBodyPr.prstTxWarp.pathLst.length / 2) >> 0) > 0);
		};

		CShape.prototype.chekBodyPrTransform = function (oBodyPr) {
			return isRealObject(oBodyPr) && isRealObject(oBodyPr.prstTxWarp) && oBodyPr.prstTxWarp.preset !== "textNoShape";
		};

		CShape.prototype.checkTextWarp = function (oContent, oBodyPr, dWidth, dHeight, bNeedNoTransform, bNeedWarp) {
			return AscFormat.ExecuteNoHistory(function () {
				var oRet = {
					oTxWarpStruct: null,
					oTxWarpStructParamarks: null,
					oTxWarpStructNoTransform: null,
					oTxWarpStructParamarksNoTransform: null
				};
				//return oRet;
				var bTransform = this.chekBodyPrTransform(oBodyPr) && bNeedWarp;
				var warpGeometry = oBodyPr.prstTxWarp;
				warpGeometry && warpGeometry.Recalculate(dWidth, dHeight);
				this.recalcInfo.warpGeometry = warpGeometry;
				var bCheckWordArtContent = this.checkContentWordArt(oContent);
				var bColumns = oContent.GetColumnCount() > 1;
				var bContentRecalculated = false;
				if (bTransform || bCheckWordArtContent) {
					var bNeedRecalc = this.checkNeedRecalcDocContentForTxWarp(oBodyPr), dOneLineWidth,
						dMinPolygonLength = 0, dKoeff = 1;
					var oTheme = this.Get_Theme(), oColorMap = this.Get_ColorMap();
					var oTextDrawer = new AscFormat.CTextDrawer(dWidth, dHeight, true, oTheme, bNeedRecalc);
					oTextDrawer.bCheckLines = bTransform && bNeedWarp;
					var oContentToDraw = oContent;
					if (bNeedRecalc && bNeedWarp) {
						oContentToDraw = oContent.Copy(oContent.Parent, oContent.DrawingDocument);
						var bNeedTurnOn = false;
						if (this.bWordShape && editor && editor.WordControl.m_oLogicDocument) {
							if (!editor.WordControl.m_oLogicDocument.TurnOffRecalc) {
								bNeedTurnOn = true;
								editor.WordControl.m_oLogicDocument.TurnOff_Recalculate();
							}
						}
						oContentToDraw.SetApplyToAll(true);
						oContentToDraw.SetParagraphSpacing({Before: 0, After: 0});
						oContentToDraw.SetApplyToAll(false);
						if (bNeedTurnOn) {
							editor.WordControl.m_oLogicDocument.TurnOn_Recalculate(false);
						}
						dMinPolygonLength = warpGeometry.getMinPathPolygonLength();
						dOneLineWidth = AscFormat.GetRectContentWidth(oContentToDraw);
						if (dOneLineWidth > dMinPolygonLength) {
							dKoeff = dMinPolygonLength / dOneLineWidth;
							oContentToDraw.Reset(0, 0, dOneLineWidth, 20000);
						} else {
							oContentToDraw.Reset(0, 0, dMinPolygonLength, 20000);
						}
						oContentToDraw.Recalculate_Page(0, true);
					} else if (bTransform && bColumns) {
						oContentToDraw = oContent.Copy(oContent.Parent, oContent.DrawingDocument);
						oContentToDraw.Reset(0, 0, oContent.XLimit, 20000);
						oContentToDraw.Recalculate_Page(0, true);
					}
					var dContentHeight = oContentToDraw.GetSummaryHeight();
					var OldShowParaMarks, width_ = dWidth * dKoeff, height_ = dHeight * dKoeff;
					if (isRealObject(editor)) {
						OldShowParaMarks = editor.ShowParaMarks;
						editor.ShowParaMarks = true;
					}
					if (bNeedWarp) {
						oContentToDraw.Draw(oContentToDraw.StartPage, oTextDrawer);
						oRet.oTxWarpStructParamarks = oTextDrawer.m_oDocContentStructure;
						oRet.oTxWarpStructParamarks.Recalculate(oTheme, oColorMap, width_, height_, this);
						if (bTransform) {
							oRet.oTxWarpStructParamarks.checkByWarpStruct(warpGeometry, dWidth, dHeight, oTheme, oColorMap, this, dOneLineWidth, oContentToDraw.XLimit, dContentHeight, dKoeff);
							if (bNeedNoTransform && bCheckWordArtContent) {
								if (oRet.oTxWarpStructParamarks.m_aComments.length > 0) {
									oContent.Recalculate_Page(0, true);
									bContentRecalculated = true;
								}
								oContent.Draw(oContent.StartPage, oTextDrawer);
								oRet.oTxWarpStructParamarksNoTransform = oTextDrawer.m_oDocContentStructure;
								oRet.oTxWarpStructParamarksNoTransform.Recalculate(oTheme, oColorMap, dWidth, dHeight, this);
								oRet.oTxWarpStructParamarksNoTransform.checkUnionPaths();
							}
						} else {
							oRet.oTxWarpStructParamarks.checkUnionPaths();
							if (bNeedNoTransform && bCheckWordArtContent) {
								oRet.oTxWarpStructParamarksNoTransform = oRet.oTxWarpStructParamarks;
							}
						}
					} else {
						if (bNeedNoTransform && bCheckWordArtContent) {
							oContent.Draw(oContent.StartPage, oTextDrawer);
							oRet.oTxWarpStructParamarksNoTransform = oTextDrawer.m_oDocContentStructure;
							oRet.oTxWarpStructParamarksNoTransform.Recalculate(oTheme, oColorMap, dWidth, dHeight, this);
							oRet.oTxWarpStructParamarksNoTransform.checkUnionPaths();
						}
					}

					if (isRealObject(editor)) {
						editor.ShowParaMarks = false;
					}
					if (bNeedWarp) {
						oContentToDraw.Draw(oContentToDraw.StartPage, oTextDrawer);
						oRet.oTxWarpStruct = oTextDrawer.m_oDocContentStructure;
						oRet.oTxWarpStruct.Recalculate(oTheme, oColorMap, width_, height_, this);
						if (bTransform) {
							oRet.oTxWarpStruct.checkByWarpStruct(warpGeometry, dWidth, dHeight, oTheme, oColorMap, this, dOneLineWidth, oContentToDraw.XLimit, dContentHeight, dKoeff);
							if (bNeedNoTransform && bCheckWordArtContent) {
								if (oRet.oTxWarpStruct.m_aComments.length > 0 && !bContentRecalculated) {
									oContent.Recalculate_Page(0, true);
								}
								oContent.Draw(oContent.StartPage, oTextDrawer);
								oRet.oTxWarpStructNoTransform = oTextDrawer.m_oDocContentStructure;
								oRet.oTxWarpStructNoTransform.Recalculate(oTheme, oColorMap, dWidth, dHeight, this);
								oRet.oTxWarpStructNoTransform.checkUnionPaths();
							}
						} else {
							oRet.oTxWarpStruct.checkUnionPaths();
							if (bNeedNoTransform && bCheckWordArtContent) {
								oRet.oTxWarpStructNoTransform = oRet.oTxWarpStruct;
							}
						}
					} else {
						if (bNeedNoTransform && bCheckWordArtContent) {
							oContent.Draw(oContent.StartPage, oTextDrawer);
							oRet.oTxWarpStructNoTransform = oTextDrawer.m_oDocContentStructure;
							oRet.oTxWarpStructNoTransform.Recalculate(oTheme, oColorMap, dWidth, dHeight, this);
							oRet.oTxWarpStructNoTransform.checkUnionPaths();
						}
					}

					if (isRealObject(editor)) {
						editor.ShowParaMarks = OldShowParaMarks;
					}
				}
				return oRet;
			}, this, []);
		};

		CShape.prototype.checkTypeCorrect = function () {
			if (!this.spPr) {
				return false;
			}
			return true;
		};


		CShape.prototype.getColumnNumber = function () {
			if (this.bWordShape) {
				return 1;
			}
			var oBodyPr = this.getBodyPr();
			if (AscFormat.isRealNumber(oBodyPr.numCol)) {
				return oBodyPr.numCol;
			}
			return 1;
		};

		CShape.prototype.getColumnSpace = function () {
			if (this.bWordShape) {
				return 0;
			}
			var oBodyPr = this.getBodyPr();
			if (AscFormat.isRealNumber(oBodyPr.spcCol)) {
				return oBodyPr.spcCol;
			}
			return 0;
		};


		CShape.prototype.getTextFitType = function () {
			var oBodyPr = this.getBodyPr();
			if (AscCommon.isRealObject(oBodyPr.textFit) && AscFormat.isRealNumber(oBodyPr.textFit.type)) {
				return oBodyPr.textFit.type;
			}
			return AscFormat.text_fit_No;
		};

		CShape.prototype.getVertOverflowType = function () {
			var oBodyPr = this.getBodyPr();
			if (AscFormat.isRealNumber(oBodyPr.vertOverflow)) {
				return oBodyPr.vertOverflow;
			}
			return AscFormat.nVOTOverflow;
		};


		CShape.prototype.checkWrap = function () {
			if (!this.txBody) {
				return;
			}
			var new_body_pr = this.getBodyPr();
			if (new_body_pr) {
				if (new_body_pr.numCol > 1) {
					if (new_body_pr.wrap === AscFormat.nTWTNone) {
						new_body_pr = new_body_pr.createDuplicate();
						new_body_pr.wrap = AscFormat.nTWTSquare;
						this.txBody.setBodyPr(new_body_pr);
					}
				}
			}
		};


		CShape.prototype.setColumnNumber = function (num) {
			if (!this.bWordShape && !CheckObjectLine(this)) {
				var new_body_pr = this.getBodyPr();
				if (new_body_pr) {
					new_body_pr = new_body_pr.createDuplicate();
					new_body_pr.numCol = (num >> 0);

					if (!this.txBody) {
						this.createTextBodyOnEdit();
					}
					if (this.txBody) {
						this.txBody.setBodyPr(new_body_pr);
					}
					this.checkWrap();
				}
			}

		};

		CShape.prototype.setColumnSpace = function (spcCol) {
			if (!this.bWordShape && !CheckObjectLine(this)) {
				var new_body_pr = this.getBodyPr();
				if (new_body_pr) {
					new_body_pr = new_body_pr.createDuplicate();
					new_body_pr.spcCol = spcCol;
					if (!this.txBody) {
						this.createTextBodyOnEdit();
					}
					if (this.txBody) {
						this.txBody.setBodyPr(new_body_pr);
					}
					this.checkWrap();
				}
			}
		};
		CShape.prototype.GetAllContentControls = function (arrContentControls) {
			var oContent = this.getDocContent();
			if (oContent) {
				oContent.GetAllContentControls(arrContentControls);
			}
		};

		CShape.prototype.getCopyWithSourceFormatting = function () {
			var oCopy = this.copy(undefined);
			if (this.pen || this.brush) {
				if (!oCopy.spPr) {
					oCopy.setSpPr(AscFormat.CSpPr());
					oCopy.spPr.setParent(oCopy);
				}
				if (this.brush) {
					oCopy.spPr.setFill(this.brush.saveSourceFormatting());
				}
				if (this.pen) {
					oCopy.spPr.setLn(this.pen.createDuplicate(true));
				}
			}
			if (oCopy.txBody && oCopy.txBody.content) {
				var oTheme = this.Get_Theme();
				var oColorMap = this.Get_ColorMap();
				if (this.txBody && this.txBody.content) {
					SaveContentSourceFormatting(this.txBody.content.Content, oCopy.txBody.content.Content, oTheme, oColorMap)
				}
			}
			if (oCopy.isPlaceholder() && !this.recalcInfo.recalculateTransform) {
				var oXfrm = oCopy.spPr.xfrm;
				if (!oXfrm || !oXfrm.isNotNull()) {
					oCopy.x = this.x;
					oCopy.y = this.y;
					oCopy.extX = this.extX;
					oCopy.extY = this.extY;
					AscFormat.CheckSpPrXfrm(oCopy, true);
				}
			}
			if (this.txXfrm) {
				oCopy.setTxXfrm(this.txXfrm.createDuplicate());
				oCopy.convertFromSmartArt();
			}
			return oCopy;
		};
		CShape.prototype.getSignatureLineGuid = function () {
			if (this.signatureLine) {
				return this.signatureLine.id;
			}
			return null;
		};

		CShape.prototype.GetAllFields = function (isUseSelection, arrFields) {
			var oContent = this.getDocContent();
			if (oContent) {
				return oContent.GetAllFields(isUseSelection, arrFields)
			}
			return arrFields ? arrFields : [];
		};
		CShape.prototype.GetAllSeqFieldsByType = function (sType, aFields) {
			var oContent = this.getDocContent();
			if (oContent) {
				return oContent.GetAllSeqFieldsByType(sType, aFields)
			}
		};

		CShape.prototype.Get_TextBackGroundColor = function () {
			if (!this.brush) {
				return undefined;
			}
			var oTheme = this.Get_Theme && this.Get_Theme();
			var oColorMap = this.Get_ColorMap && this.Get_ColorMap();
			if (oTheme && oColorMap) {
				this.brush.check(oTheme, oColorMap);
			}
			return this.brush.Get_TextBackGroundColor();
		};

		CShape.prototype.checkResetAutoFit = function (bCheckMinVal) {
			if (this.txBody) {
				var oCompiledBodyPr = this.getBodyPr();
				var oNewBodyPr;
				var oTextFit = oCompiledBodyPr.textFit;
				if (oTextFit) {
					if (oTextFit.type === AscFormat.text_fit_NormAuto) {
						if (AscFormat.isRealNumber(oTextFit.fontScale)) {
							if (oTextFit.fontScale < 100000) {
								var bReset = false;
								if (bCheckMinVal) {
									if (oTextFit.fontScale <= 25000) {
										bReset = true;
										var oContent = this.txBody.content;
										if (oContent) {
											oContent.CheckRunContent(function (oRun) {
												var oTextPr = oRun.Pr;
												var oCompiledPr = oRun.CompiledPr;
												if (AscFormat.isRealNumber(oTextPr.FontSize) &&
													AscFormat.isRealNumber(oCompiledPr.FontSize) &&
													oTextPr.FontSize !== oCompiledPr.FontSize) {
													oRun.SetFontSize(oCompiledPr.FontSize);
													if (oRun.IsParaEndRun()) {
														var oParagraph = oRun.Paragraph;
														if (oParagraph) {
															oParagraph.TextPr.Apply_TextPr(oTextPr);
														}
													}
												}
											});
										}
									}
								} else {
									bReset = true;
								}
								if (bReset) {
									oNewBodyPr = oCompiledBodyPr.createDuplicate();
									oNewBodyPr.textFit = new AscFormat.CTextFit();
									oNewBodyPr.textFit.type = AscFormat.text_fit_No;
									this.txBody.setBodyPr(oNewBodyPr);
								}
							}
						}
					}
				}
			}
		};
		CShape.prototype.getInnerForm = function () {
			return this.textBoxContent ? this.textBoxContent.GetInnerForm() : null;
		};
		CShape.prototype.getFormHorPadding = function () {
			let oInnerForm;
			if (this.isForm
				&& this.isForm()
				&& (oInnerForm = this.getInnerForm())
				&& !oInnerForm.IsPictureForm()
				&& !oInnerForm.IsCheckBox()
				&& (!oInnerForm.IsTextForm() || !oInnerForm.GetTextFormPr().IsComb()))
				return 2 * 25.4 / 72; // 2pt

			return 0;
		};

		//for bug 52775. remove in the next version
		CShape.prototype.applySmartArtTextStyle = function () {
			if (this.textBoxContent) {
				if (this.style && this.style.fontRef) {
					if (this.style.fontRef.Color) {
						var oUnifill = AscFormat.CreateUniFillByUniColorCopy(this.style.fontRef.Color);
						this.textBoxContent.CheckRunContent(function (oRun) {
							if (oRun instanceof AscCommonWord.ParaRun) {
								if (!oRun.Pr.Unifill && !oRun.Pr.TextFill) {
									oRun.Set_Unifill(oUnifill);
								}
							}
							return false;
						});
					}
				}
			}
		};

		CShape.prototype.getTypeName = function () {
			if (this.isPlaceholder()) {
				return this.getPlaceholderName();
			}
			var sPreset = this.getPresetGeom();
			if (typeof sPreset === "string" && sPreset.length > 0) {
				var oApi = Asc.editor || editor;
				return oApi.getShapeName(sPreset);
			}
			return AscCommon.translateManager.getValue("Shape");
		};

		CShape.prototype.applyImagePlaceholderCallback = function (aImages, oPlaceholder) {
			var _image = aImages[0];
			if (this.isObjectInSmartArt()) {
				if (this.spPr) {
					const imageWidth = _image.Image.width;
					const imageHeight = _image.Image.height;
					const shapeWidth = this.extX;
					const shapeHeight = this.extY;
					const srcRect = new AscFormat.CSrcRect();
					srcRect.setValueForFitBlipFill(shapeWidth, shapeHeight, imageWidth, imageHeight);
					const oBlipFillUniFill = AscFormat.CreateBlipFillUniFillFromUrl(_image.src);
					oBlipFillUniFill.fill.setSrcRect(srcRect);
					this.changeFill(oBlipFillUniFill);
				}
			}
			return true;
		};

		CShape.prototype.checkEditTextStyle = function (fDocContentMethod, params, bSelect) {
			let nParentType = null;
			if(this.parent && this.parent.getObjectType) {
				nParentType = this.parent.getObjectType();
			}
			if(nParentType !== AscDFH.historyitem_type_SlideMaster &&
				nParentType !== AscDFH.historyitem_type_SlideLayout) {
				return false;
			}
			if(!this.isPlaceholder()) {
				return false;
			}
			let oTxBody = this.txBody;
			if(!oTxBody) {
				return false;
			}
			let oContent = oTxBody.content;
			if(!oContent) {
				return false;
			}
			let oParaPrToApply = new AscWord.CParaPr();
			let bIncreaseFontSize = null;
			let oDCP = AscFormat.CDrawingDocContent.prototype;
			if(fDocContentMethod === oDCP.Set_ParagraphPresentationNumbering) {
				oParaPrToApply.Bullet = params[0];
			}
			else if(fDocContentMethod === oDCP.SetParagraphIndent) {
				oParaPrToApply.Ind = new CParaInd();
				oParaPrToApply.Ind.Set_FromObject(params[0]);
			}
			else if(fDocContentMethod === oDCP.ClearParagraphFormatting) {
				oParaPrToApply = null;
				if(nParentType === AscDFH.historyitem_type_SlideMaster) {
					return true;
				}
			}
			else if(fDocContentMethod === oDCP.SetParagraphSpacing) {
				oParaPrToApply.Spacing = new CParaSpacing();
				oParaPrToApply.Spacing.Set_FromObject(params[0]);
			}
			else if(fDocContentMethod === oDCP.IncreaseDecreaseFontSize) {
				bIncreaseFontSize = params[0];
			}
			else if(fDocContentMethod === oDCP.SetParagraphAlign) {
				oParaPrToApply.Jc = params[0];
			}
			else if(fDocContentMethod === CDocumentContent.prototype.AddToParagraph && params[0].Type === para_TextPr) {
				oParaPrToApply.DefaultRunPr = params[0].Value;
			}
			else {
				return false;
			}

			let oTextStyles;
			if(oTxBody.lstStyle) {
				oTextStyles = oTxBody.lstStyle.createDuplicate();
			}
			else {
				oTextStyles = new AscFormat.TextListStyle();
			}
			if(bSelect) {
				let oLvls = {};
				let aParagraphs = [];
				oContent.GetCurrentParagraph(false, aParagraphs, {});
				for(let nIdx = 0; nIdx < aParagraphs.length; ++nIdx) {
					let oParagraph = aParagraphs[nIdx];
					let nLvl = 0;
					if(AscFormat.isRealNumber(oParagraph.Pr.Lvl)) {
						nLvl = oParagraph.Pr.Lvl;
					}
					if(!oLvls[nLvl]) {
						oTextStyles.applyParaPr(nLvl, oParaPrToApply, bIncreaseFontSize, this);
						oLvls[nLvl] = true;
					}
				}
			}
			else {
				for(let nLvl = 0; nLvl < 9; ++nLvl) {
					oTextStyles.applyParaPr(nLvl, oParaPrToApply, bIncreaseFontSize, this);
				}
			}
			oTxBody.setLstStyle(oTextStyles);
			return true;
		};

		CShape.prototype.pasteFormatting = function (oFormatData) {
			if(!oFormatData)
				return;
			let oDrawing = oFormatData.Drawing;
			if(oDrawing) {
				this.pasteDrawingFormatting(oFormatData.Drawing);
			}
			let oContent = this.getDocContent();
			if(oContent) {
				let bApplyToAll = true;
				let oController = this.getDrawingObjectsController && this.getDrawingObjectsController();
				if(oController) {
					if(AscFormat.getTargetTextObject(oController) === this) {
						bApplyToAll = false;
					}
				}
				if(bApplyToAll) {
					oContent.SetApplyToAll(true);
				}
				let fDocContentMethod = AscCommonWord.CDocumentContent.prototype.ClearParagraphFormatting;
				let fTableMethod = AscCommonWord.CTable.prototype.ClearParagraphFormatting;
				this.applyTextFunction(fDocContentMethod, fTableMethod, [oFormatData]);
				if(oFormatData.ParaPr || oFormatData.TextPr) {
					let fDocContentMethod = AscCommonWord.CDocumentContent.prototype.PasteFormatting;
					let fTableMethod = AscCommonWord.CTable.prototype.PasteFormatting;
					this.applyTextFunction(fDocContentMethod, fTableMethod, [oFormatData]);
				}
				if(bApplyToAll) {
					oContent.SetApplyToAll(false);
				}
			}
		};

		CShape.prototype.getText = function() {
			const oContent = this.getDocContent();
			if(!oContent) {
				return "";
			}
			oContent.SetApplyToAll(true);
			const sText = oContent.GetSelectedText(true, {});
			oContent.SetApplyToAll(false);
			return sText;
		};

		CShape.prototype.compareForMorph = function(oDrawingToCheck, oCurCandidate, oMapPaired) {

			if(!oDrawingToCheck) {
				return oCurCandidate;
			}
			const nOwnType = this.getObjectType();
			const nCheckType = oDrawingToCheck.getObjectType();
			if(nOwnType !== nCheckType) {
				return oCurCandidate;
			}
			const sName = this.getOwnName();
			const sText = this.getText();
			const sPreset = this.getPresetGeom();
			let sOwnImageId, sCheckImageId, sCandidateImageId;
			if(this.blipFill) {
				sOwnImageId = this.blipFill.RasterImageId;
			}
			if(oDrawingToCheck.blipFill) {
				sCheckImageId = oDrawingToCheck.blipFill.RasterImageId;
			}
			if(oCurCandidate) {
				if(oCurCandidate.blipFill) {
					sCandidateImageId = oCurCandidate.blipFill.RasterImageId;
				}
			}
			if(sName && sName.startsWith(AscFormat.OBJECT_MORPH_MARKER)) {
				const sCheckName = oDrawingToCheck.getOwnName();
				if(sName !== sCheckName) {
					return oCurCandidate;
				}
			}
			else {
				if(sOwnImageId && sOwnImageId !== sCheckImageId) {
					return oCurCandidate;
				}
				if(oDrawingToCheck.getText() !== sText) {
					return oCurCandidate;
				}
				if(sPreset !== oDrawingToCheck.getPresetGeom()) {
					return oCurCandidate;
				}
			}
			let oGeometry = this.getGeometry();
			let oCheckGeometry = oDrawingToCheck.getGeometry();
			let oCandidateGeometry = oCurCandidate && oCurCandidate.getGeometry();
			if(!oMapPaired || !oMapPaired[oDrawingToCheck.Id] ||
				oGeometry && oCheckGeometry && oCheckGeometry && oCheckGeometry.isEqualForMorph(oGeometry)) {
				if(!oCurCandidate) {
					if(oMapPaired && oMapPaired[oDrawingToCheck.Id]) {
						let oParedDrawing = oMapPaired[oDrawingToCheck.Id].drawing;
						if(oParedDrawing.getOwnName() === oDrawingToCheck.getOwnName()) {
							return oCurCandidate;
						}
						let dSizeMCandidate = Math.abs(oParedDrawing.extX - oDrawingToCheck.extX) + Math.abs(oParedDrawing.extY - oDrawingToCheck.extY);
						let dSizeMCheck = Math.abs(oDrawingToCheck.extX - this.extX) + Math.abs(oDrawingToCheck.extY - this.extY);
						if(dSizeMCandidate < dSizeMCheck) {
							return oCurCandidate;
						}
					}
					return oDrawingToCheck;
				}
				if(sOwnImageId) {
					if(sCheckImageId !== sOwnImageId && sCandidateImageId === sOwnImageId) {
						return oCurCandidate;
					}
					if(sCheckImageId === sOwnImageId && sCandidateImageId !== sOwnImageId) {
						return oDrawingToCheck;
					}
				}
				if(oDrawingToCheck.getText() !== sText && oCurCandidate.getText() === sText) {
					return oCurCandidate;
				}
				if(oDrawingToCheck.getText() === sText && oCurCandidate.getText() !== sText) {
					return oDrawingToCheck;
				}
				if(sPreset) {
					if(oDrawingToCheck.getPresetGeom() !== sPreset && oCurCandidate.getPresetGeom() === sPreset) {
						return oCurCandidate;
					}
					if(oDrawingToCheck.getPresetGeom() === sPreset && oCurCandidate.getPresetGeom() !== sPreset) {
						return oDrawingToCheck;
					}
				}
				else {
					oGeometry = this.getGeometry();
					oCheckGeometry = oDrawingToCheck.getGeometry();
					oCandidateGeometry = oCurCandidate.getGeometry();
					if(oGeometry && oCheckGeometry && oCandidateGeometry) {
						let bCheckEqualGeom = oCheckGeometry.isEqualForMorph(oGeometry);
						let bCandidateEqualGeom = oCandidateGeometry.isEqualForMorph(oGeometry);
						if(!bCheckEqualGeom && bCandidateEqualGeom) {
							return oCurCandidate;
						}
						if(bCheckEqualGeom && !bCandidateEqualGeom) {
							return oDrawingToCheck;
						}
					}
				}
				const oBrush = this.brush;
				const oPen = this.pen;
				const oBrushCheck = oDrawingToCheck.brush;
				const oPenCheck = oDrawingToCheck.pen;
				const oBrushCandidate = oCurCandidate.brush;
				const oPenCandidate = oCurCandidate.pen;
				const bBrushCheckEqual = !oBrush && !oBrushCheck || oBrush && oBrush.isEqual(oBrushCheck);
				const bPenCheckEqual = !oPen && !oPenCheck || oPen && oPen.isEqual(oPenCheck);
				const bBrushPenCheckEqual = bBrushCheckEqual && bPenCheckEqual;

				const bBrushCandidateEqual = !oBrush && !oBrushCandidate || oBrush && oBrush.isEqual(oBrushCandidate);
				const bPenCandidateEqual = !oPen && !oPenCandidate || oPen && oPen.isEqual(oPenCandidate);
				const bBrushPenCandidateEqual = bBrushCandidateEqual && bPenCandidateEqual;
				if(bBrushPenCheckEqual && !bBrushPenCandidateEqual) {
					return oDrawingToCheck;
				}
				if(!bBrushPenCheckEqual && bBrushPenCandidateEqual) {
					return oCurCandidate;
				}
				if(bBrushCheckEqual && !bBrushCandidateEqual) {
					return oDrawingToCheck;
				}
				if(!bBrushCheckEqual && bBrushCandidateEqual) {
					return oCurCandidate;
				}
				if(bPenCheckEqual && !bPenCandidateEqual) {
					return oDrawingToCheck;
				}
				if(!bPenCheckEqual && bPenCandidateEqual) {
					return oCurCandidate;
				}
				const dDistCheck = this.getDistanceL1(oDrawingToCheck);
				const dDistCur = this.getDistanceL1(oCurCandidate);
				let dSizeMCandidate = Math.abs(oCurCandidate.extX - this.extX) + Math.abs(oCurCandidate.extY - this.extY);
				let dSizeMCheck = Math.abs(oDrawingToCheck.extX - this.extX) + Math.abs(oDrawingToCheck.extY - this.extY);
				if(dSizeMCandidate < dSizeMCheck) {
					return  oCurCandidate;
				}
				else {
					if(dDistCur < dDistCheck) {
						return  oCurCandidate;
					}
				}
				if(!oMapPaired || !oMapPaired[oDrawingToCheck.Id]) {
					return oDrawingToCheck;
				}
				else {
					let oParedDrawing = oMapPaired[oDrawingToCheck.Id].drawing;
					if(oParedDrawing.getOwnName() === oDrawingToCheck.getOwnName()) {
						return oCurCandidate;
					}
					else {
						return oDrawingToCheck;
					}
				}
			}
			return  oCurCandidate;
		};
		CShape.prototype.checkDrawingPartWithHistory = function () {};
		CShape.prototype.getDocStructure = function (oParagraphSplitOptions, oIdGenerator) {
			return AscFormat.ExecuteNoHistory(function () {
				oParagraphSplitOptions = oParagraphSplitOptions || {};
				const oDocContent = this.getDocContent();
				if (oDocContent) {
					const oTheme = oDocContent.Get_Theme();
					const oColorMap = oDocContent.Get_ColorMap();
					const oTransform = this.transformText;
					const oTextDrawer = new AscFormat.CTextDrawer(oDocContent.XLimit, oDocContent.YLimit, false, oDocContent.Get_Theme(), true, oParagraphSplitOptions, oIdGenerator);
					oDocContent.Draw(oDocContent.StartPage, oTextDrawer);
					const oDocStructure = oTextDrawer.m_oDocContentStructure;
					for (let i = 0; i < oDocStructure.m_aContent.length; i += 1) {
						const oParagraph = oDocStructure.m_aContent[i];
						oParagraph.generateWrappersBySplit(oParagraphSplitOptions[i], oTransform, oTheme, oColorMap, this);
					}
					oTextDrawer.clearTextElements();
					return oDocStructure;
				}
				return null;
			}, this, []);
		};

		function CreateBinaryReader(szSrc, offset, srcLen) {
			var memoryData = AscCommon.Base64.decode(szSrc, true, srcLen, offset);
			return new AscCommon.FT_Stream2(memoryData, memoryData.length);
		}
		function CreatePPTYLoader(szSrc, offset, srcLen) {
			let stream = CreateBinaryReader(szSrc, offset, srcLen);
			let oBinaryReader = new AscCommon.BinaryPPTYLoader();
			oBinaryReader.stream = new AscCommon.FileStream();
			oBinaryReader.stream.obj = stream.obj;
			oBinaryReader.stream.data = stream.data;
			oBinaryReader.stream.size = stream.size;
			oBinaryReader.stream.pos = stream.pos;
			oBinaryReader.stream.cur = stream.cur;
			return oBinaryReader;
		}

		function getParaDrawing(oDrawing) {
			var oCurDrawing = oDrawing;
			while (oCurDrawing.group) {
				oCurDrawing = oCurDrawing.group;
			}
			if (oCurDrawing.parent instanceof AscCommonWord.ParaDrawing) {
				return oCurDrawing.parent;
			}
			return null;
		}

		function checkDrawingsTransformBeforePaste(oEndContent, oSourceContent, oTempParent) {
			var i, j;
			for (i = 0; i < oEndContent.Drawings.length; ++i) {
				var shape = oEndContent.Drawings[i].Drawing;
				if (shape.isPlaceholder && shape.isPlaceholder() && (!shape.spPr || !shape.spPr.xfrm || !shape.spPr.xfrm.isNotNull())) {
					var oOldParent = shape.parent;
					shape.parent = oTempParent;
					var hierarchy = shape.getHierarchy();
					for (j = 0; j < hierarchy.length; ++j) {
						if (hierarchy[j] && hierarchy[j].spPr && hierarchy[j].spPr.xfrm && hierarchy[j].spPr.xfrm.isNotNull()) {
							break;
						}
					}
					if (j === hierarchy.length) {
						if (oSourceContent.Drawings[i] && oSourceContent.Drawings[i].Drawing) {
							var oSourceShape = oSourceContent.Drawings[i].Drawing;
							if (oSourceShape && oSourceShape.spPr && oSourceShape.spPr.xfrm && oSourceShape.spPr.xfrm.isNotNull()) {
								shape.x = oSourceShape.spPr.xfrm.offX;
								shape.y = oSourceShape.spPr.xfrm.offY;
								shape.extX = oSourceShape.spPr.xfrm.extX;
								shape.extY = oSourceShape.spPr.xfrm.extY;
								AscFormat.CheckSpPrXfrm(shape);
							}
						}
					}
					shape.parent = oOldParent;
				}
			}
		}


		function SaveSourceFormattingTextPr(oTextPr, oTheme, oColorMap) {
			oTextPr.ReplaceThemeFonts(oTheme.themeElements.fontScheme);
			if (oTextPr.Unifill) {
				oTextPr.Unifill.check(oTheme, oColorMap);
				oTextPr.Unifill = oTextPr.Unifill.saveSourceFormatting();
			}
			if (oTextPr.TextOutline && oTextPr.TextOutline.Fill) {
				oTextPr.TextOutline.Fill.check(oTheme, oColorMap);
				oTextPr.TextOutline.Fill = oTextPr.TextOutline.Fill.saveSourceFormatting();
			}
			return oTextPr;
		}

		function SaveContentSourceFormatting(aSourceContent, aCopyContent, oTheme, oColorMap) {
			if (aCopyContent.length === aSourceContent.length) {
				var bMergeRunPr = (aCopyContent === aSourceContent);
				var oElem;
				for (var i = 0; i < aSourceContent.length; ++i) {
					oElem = aSourceContent[i];
					if (oElem.CompiledPr.Pr) {
						var oPr = oElem.CompiledPr.Pr.ParaPr.Copy();
						oPr.DefaultRunPr = SaveSourceFormattingTextPr(oElem.CompiledPr.Pr.TextPr.Copy(), oTheme, oColorMap);
						aCopyContent[i].Set_Pr(oPr);
						SaveRunsFormatting(oElem.Content, aCopyContent[i].Content, oTheme, oColorMap, oPr);
					} else {
						if (aCopyContent[i].Pr && aCopyContent[i].Pr.DefaultRunPr && aCopyContent[i].Pr.DefaultRunPr.Unifill) {
							var oPr = aCopyContent[i].Pr.Copy();
							oPr.DefaultRunPr.Unifill.check(oTheme, oColorMap);
							oPr.DefaultRunPr.Unifill = oPr.DefaultRunPr.Unifill.saveSourceFormatting();
							oPr.DefaultRunPr = SaveSourceFormattingTextPr(oPr.DefaultRunPr.Copy(), oTheme, oColorMap);
							aCopyContent[i].Set_Pr(oPr);
						}
					}
				}
			}
		}

		function SaveRunsFormatting(aSourceContent, aCopyContent, oTheme, oColorMap, oPr) {
			var bMergeRunPr = (aCopyContent === aSourceContent);
			if(aCopyContent.length !== aSourceContent.length) {
				return;
			}
			for (var i = 0; i < aCopyContent.length; ++i) {
				if (aCopyContent[i] instanceof ParaRun && aCopyContent[i].Pr) {
					if (bMergeRunPr) {
						var oCoprPr = oPr.DefaultRunPr.Copy();
						oCoprPr.Merge(SaveSourceFormattingTextPr(aCopyContent[i].Pr.Copy(), oTheme, oColorMap));
						aCopyContent[i].Set_Pr(oCoprPr)
					} else {
						aCopyContent[i].Set_Pr(SaveSourceFormattingTextPr(aCopyContent[i].Pr.Copy(), oTheme, oColorMap));
					}

				} else if (aSourceContent[i].Content) {
					var oElem = aSourceContent[i];
					SaveRunsFormatting(oElem.Content, aCopyContent[i].Content, oTheme, oColorMap, oPr);
					if (oElem.Get_CompiledCtrPrp && aCopyContent[i].setCtrPrp) {
						var oCtrPr = oElem.Get_CompiledCtrPrp();
						aCopyContent[i].setCtrPrp(oCtrPr);
					}
				} else if (aSourceContent[i] instanceof AscCommonWord.ParaMath && aSourceContent[i].Root && aSourceContent[i].Root.Content) {
					SaveRunsFormatting(aSourceContent[i].Root.Content, aCopyContent[i].Root.Content, oTheme, oColorMap, oPr);

				}
			}
		}


		AscFormat.checkPlaceholdersText = function () {
			if (AscFonts.IsCheckSymbols) {
				for (var i = AscFormat.pHText.length - 1; i >= 0; i--)
					AscFonts.FontPickerByCharacter.getFontsByString(AscCommon.translateManager.getValue(AscFormat.pHText[i]));
			}
		};

		function isShowParaMarksInTextArt(shape, bCurrentEditText) {
			if(!Asc.editor.ShowParaMarks) return false;
			if(bCurrentEditText) return true;
			if(shape.chekBodyPrTransform(shape.getBodyPr())) return false;
			return true;
		}
		//--------------------------------------------------------export----------------------------------------------------
		window['AscFormat'] = window['AscFormat'] || {};
		window['AscFormat'].CheckObjectLine = CheckObjectLine;
		window['AscFormat'].CreateUniFillByUniColorCopy = CreateUniFillByUniColorCopy;
		window['AscFormat'].CreateUniFillByUniColor = CreateUniFillByUniColor;
		window['AscFormat'].ConvertParagraphToPPTX = ConvertParagraphToPPTX;
		window['AscFormat'].ConvertElementsToPPTX = ConvertElementsToPPTX;
		window['AscFormat'].ConvertParagraphToWord = ConvertParagraphToWord;
		window['AscFormat'].SetXfrmFromMetrics = SetXfrmFromMetrics;
		window['AscFormat'].CShape = CShape;
		window['AscFormat'].CreateBinaryReader = CreateBinaryReader;
		window['AscFormat'].CreatePPTYLoader = CreatePPTYLoader;
		window['AscFormat'].getParaDrawing = getParaDrawing;
		window['AscFormat'].ConvertGraphicFrameToWordTable = ConvertGraphicFrameToWordTable;
		window['AscFormat'].ConvertTableToGraphicFrame = ConvertTableToGraphicFrame;
		window['AscFormat'].CSignatureLine = CSignatureLine;
		window['AscFormat'].checkDrawingsTransformBeforePaste = checkDrawingsTransformBeforePaste;
		window['AscFormat'].SaveContentSourceFormatting = SaveContentSourceFormatting;
		window['AscFormat'].hitToHandles = hitToHandles;
		window['AscFormat'].pHText = pHText;
		window['AscFormat'].fitSmartArtShapes = fitSmartArtShapes;
		window['AscFormat'].fCheckContentImages = fCheckContentImages;
	})(window);